Fix (Performance): Smooth only non-planar quad meshes

Merging 2.13 hotfixes into dev branch

speckle_connector/src/constants/type_constants.rb

@@ -3,6 +3,8 @@
 module SpeckleConnector
   BASE_OBJECT = 'Base'
 
+  OBJECTS_GIS_POLYGONELEMENT = 'Objects.GIS.PolygonElement'
+
   OBJECTS_BUILTELEMENTS_VIEW3D = 'Objects.BuiltElements.View:Objects.BuiltElements.View3D'
   OBJECTS_BUILTELEMENTS_REVIT_DIRECTSHAPE = 'Objects.BuiltElements.Revit.DirectShape'
   OBJECTS_BUILTELEMENTS_REVIT_LEVEL = 'Objects.BuiltElements.Level:Objects.BuiltElements.Revit.RevitLevel'

speckle_connector/src/convertors/to_native.rb

@@ -2,6 +2,7 @@
 
 require_relative 'converter'
 require_relative '../constants/type_constants'
+require_relative '../speckle_objects/gis/polygon_element'
 require_relative '../speckle_objects/other/transform'
 require_relative '../speckle_objects/other/render_material'
 require_relative '../speckle_objects/other/block_definition'
@@ -37,6 +38,7 @@ module SpeckleConnector
       OTHER = SpeckleObjects::Other
       REVIT = SpeckleObjects::Revit
       BUILTELEMENTS = SpeckleObjects::BuiltElements
+      GIS = SpeckleObjects::GIS
 
       # Class aliases
       POINT = GEOMETRY::Point
@@ -48,6 +50,7 @@ module SpeckleConnector
       RENDER_MATERIAL = OTHER::RenderMaterial
       DISPLAY_VALUE = OTHER::DisplayValue
       VIEW3D = BUILTELEMENTS::View3d
+      POLYGON_ELEMENT = GIS::PolygonElement
 
       BASE_OBJECT_PROPS = %w[applicationId id speckle_type totalChildrenCount].freeze
       CONVERTABLE_SPECKLE_TYPES = %w[
@@ -61,6 +64,7 @@ module SpeckleConnector
         Objects.Other.RenderMaterial
         Objects.Other.Instance:Objects.Other.BlockInstance
         Objects.BuiltElements.View:Objects.BuiltElements.View3D
+        Objects.GIS.PolygonElement
       ].freeze
 
       def from_revit
@@ -71,6 +75,10 @@ module SpeckleConnector
         @from_sketchup ||= source_app.include?('sketchup')
       end
 
+      def from_qgis
+        @from_qgis ||= source_app.include?('qgis')
+      end
+
       # ReceiveObjects action call this method by giving everything that comes from server.
       # Upcoming object is a referencedObject of selected commit to receive.
       # UI is responsible currently to fetch objects from ObjectLoader module by calling getAndConstruct method.
@@ -95,13 +103,23 @@ module SpeckleConnector
         traverse_commit_object(obj, @entities_to_fill)
         create_levels_from_section_planes
         check_hiding_layers_needed
-
-        if !from_sketchup && !@is_update_commit
-          sketchup_model.entities.add_instance(@branch_definition, Geom::Transformation.new)
-        end
+        try_create_instance
         @state
       end
 
+      # Creating instance from @branch_definition only available for non-sketchup commits since we wrap commits
+      # under instance.
+      # There is also another use case that maybe definition is exist in file but user might be deleted it before.
+      # If this is the case we can add instance by checking number of instances.
+      # rubocop:disable Style/GuardClause
+      def try_create_instance
+        if !from_sketchup && (!@is_update_commit || @branch_definition.instances.empty?)
+          instance = sketchup_model.entities.add_instance(@branch_definition, Geom::Transformation.new)
+          BLOCK_INSTANCE.align_instance_axes(instance) if from_qgis
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
       def levels_layer
         @levels_layer ||= sketchup_model.layers.add('Levels')
       end
@@ -253,7 +271,8 @@ module SpeckleConnector
         OBJECTS_OTHER_BLOCKINSTANCE_FULL => BLOCK_INSTANCE.method(:to_native),
         OBJECTS_OTHER_REVIT_REVITINSTANCE => REVIT_INSTANCE.method(:to_native),
         OBJECTS_OTHER_RENDERMATERIAL => RENDER_MATERIAL.method(:to_native),
-        OBJECTS_BUILTELEMENTS_VIEW3D => VIEW3D.method(:to_native)
+        OBJECTS_BUILTELEMENTS_VIEW3D => VIEW3D.method(:to_native),
+        OBJECTS_GIS_POLYGONELEMENT => POLYGON_ELEMENT.method(:to_native)
       }.freeze
 
       # @param state [States::State] state of the speckle application

speckle_connector/src/sketchup_model/utils/plane_utils.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  # Operations related to {SketchupModel}.
+  module SketchupModel
+    # Works directly with/on SketchUp Entities of different kinds (Groups, Faces, Edges, ...).
+    module Utils
+      # Static methods to do plane calculations with sketchup geom objects like Point3d and Vector3d.
+      class Plane
+        LENGTH_TOLERANCE = 1e-8
+
+        # Create plane from 3 points
+        # @param origin [Geom::Point3d] the point on the plane that wil become the origin of the local coordinate system
+        # @param point_1 [Geom::Point3d] the point that defines first direction
+        # @param point_2 [Geom::Point3d] the third point on the plane
+        # @return [Plane] the parametrization of the plane that goes through the given points
+        def self.from_points(origin, point_1, point_2)
+          direction_x = origin.vector_to(point_1).normalize
+          direction_x = direction_x.normalize
+          normal = direction_x.cross(origin.vector_to(point_2))
+          direction_y = direction_x.cross(normal.normalize)
+          new(origin: origin, direction_u: direction_x, direction_v: direction_y)
+        end
+
+        # @return [Geom::Vector3d] the direction of the u-axis on the plane
+        attr_reader :direction_u
+
+        # @return [Geom::Vector3d] the direction of the v-axis on the plane
+        attr_reader :direction_v
+
+        # @return [Geom::Point3d] the origin of the local coordinate system on the plane
+        attr_reader :origin
+
+        # @param origin [Geom::Point3d] the origin of the coordinate system on the plane
+        # @param direction_u [Geom::Vector3d] the direction of the x-axis
+        # @param direction_v [Geom::Vector3d] the direction of the y-axis
+        def initialize(origin:, direction_u:, direction_v:)
+          @origin = origin
+          @direction_u = direction_u
+          @direction_v = direction_v
+        end
+
+        # Get the point object in global coordinates for the point on the plane with local coordinates (u,v).
+        # @param coordinate_u [Float] the u-coordinate on the plane
+        # @param coordinate_v [Float] the v-coordinate on the plane
+        # @return [Geom::Point3d] the point in space that corresponds to the given (u, v) coordinates
+        def point_at(coordinate_u, coordinate_v)
+          scaled_direction_u = Geom::Vector3d.new(direction_u.x * coordinate_u,
+                                                  direction_u.y * coordinate_u,
+                                                  direction_u.z * coordinate_u)
+          scaled_direction_v = Geom::Vector3d.new(direction_v.x * coordinate_v,
+                                                  direction_v.y * coordinate_v,
+                                                  direction_v.z * coordinate_v)
+          origin + scaled_direction_u + scaled_direction_v
+        end
+
+        # Find local (u, v) coordinates of the projection of the given point to the plane
+        # @param point [Geom::Point3d] the point that will be projected to the plane
+        # @return [(Float, Float)] the local coordinates on the plane that correspond to the projected point
+        def plane_coordinates(point)
+          origin_to_point = origin.vector_to(point)
+          coordinate_u = origin_to_point.dot(direction_u)
+          coordinate_v = origin_to_point.dot(direction_v)
+          [coordinate_u, coordinate_v]
+        end
+
+        # Project a given point to the plane
+        # @param point [Geom::Point3d] the point that will be projected to the plane
+        # @return [Geom::Point3d] the projected point on the plane
+        def project_to_plane(point)
+          coordinate_u, coordinate_v = plane_coordinates(point)
+          point_at(coordinate_u, coordinate_v)
+        end
+
+        # Check if the given point lies on the plane
+        # @param point [Geom::Point3d] the point to check
+        # @return [Boolean] whether the point lies on the plane
+        def on_plane?(point)
+          point.distance(project_to_plane(point)).to_m < LENGTH_TOLERANCE
+        end
+      end
+    end
+  end
+end

speckle_connector/src/speckle_objects/built_elements/view3d.rb

@@ -93,9 +93,9 @@ module SpeckleConnector
           set_rendering_options(page.rendering_options, view['rendering_options']) if view['rendering_options']
           return state, [page]
         end
+
         # rubocop:enable Metrics/AbcSize
         # rubocop:enable Metrics/CyclomaticComplexity
-
         # @param page [Sketchup::Page] scene to update -update properties-
         def self.set_page_update_properties(page, update_properties)
           update_properties.each do |prop, value|

speckle_connector/src/speckle_objects/geometry/line.rb

@@ -65,6 +65,8 @@ module SpeckleConnector
         # @param layer [Sketchup::Layer] layer to add {Sketchup::Edge} into it.
         # @param entities [Sketchup::Entities] entities collection to add {Sketchup::Edge} into it.
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
         def self.to_native(state, line, entities, &_convert_to_native)
           if line.key?('value')
             values = line['value']
@@ -87,6 +89,8 @@ module SpeckleConnector
           return state, edges
         end
         # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def self.test_line(start_point, end_point, units)
           domain = Primitive::Interval.from_numeric(0, 5, units)
@@ -94,6 +98,7 @@ module SpeckleConnector
             start_pt: start_point,
             end_pt: end_point,
             domain: domain,
+            layer: 'test',
             application_id: '',
             units: units
           )

speckle_connector/src/speckle_objects/geometry/mesh.rb

@@ -7,6 +7,8 @@ require_relative '../../sketchup_model/query/entity'
 require_relative '../../convertors/clean_up'
 require_relative '../../sketchup_model/dictionary/base_dictionary_handler'
 require_relative '../../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+require_relative '../../sketchup_model/dictionary/dictionary_handler'
+require_relative '../../sketchup_model/utils/plane_utils'
 
 module SpeckleConnector
   module SpeckleObjects
@@ -52,6 +54,26 @@ module SpeckleConnector
         end
         # rubocop:enable Metrics/ParameterLists
 
+        # Checks 4 points are planar or not.
+        def self.check_4_points_planar(points)
+          plane = SketchupModel::Utils::Plane.from_points(points[0], points[1], points[2])
+          plane.on_plane?(points[3])
+        end
+
+        # Add quad mesh to sketchup native mesh by checking planarity.
+        # @param native_mesh [Geom::Mesh] sketchup mesh to convert them later faces.
+        # @param polygon_points [Array<Geom::Point3d>] sketchup points to add them with polygon to mesh.
+        def self.add_quad_mesh(native_mesh, polygon_points)
+          is_planar = check_4_points_planar(polygon_points)
+          if is_planar
+            native_mesh.add_polygon(polygon_points)
+          else
+            native_mesh.add_polygon([polygon_points[0], polygon_points[1], polygon_points[2]])
+            native_mesh.add_polygon([polygon_points[0], polygon_points[2], polygon_points[3]])
+          end
+          is_planar
+        end
+
         # @param entities [Sketchup::Entities] entities to add
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
@@ -67,12 +89,20 @@ module SpeckleConnector
           # Initialize native PolygonMesh object later to add polygon inside it.
           native_mesh = Geom::PolygonMesh.new(mesh['vertices'].count / 3)
           faces = mesh['faces']
+          has_any_non_planar_quad_mesh = false
           while faces.count > 0
             num_pts = faces.shift
             # 0 -> 3, 1 -> 4 to preserve backwards compatibility
             num_pts += 3 if num_pts < 3
             indices = faces.shift(num_pts)
-            native_mesh.add_polygon(indices.map { |index| points[index] })
+            polygon_points = indices.map { |index| points[index] }
+            # Quad mesh
+            if num_pts == 4
+              is_planar = add_quad_mesh(native_mesh, polygon_points)
+              has_any_non_planar_quad_mesh = true unless is_planar
+            else
+              native_mesh.add_polygon(polygon_points)
+            end
           end
           state, _materials = Other::RenderMaterial.to_native(state, mesh['renderMaterial'],
                                                               entities, &convert_to_native)
@@ -89,6 +119,9 @@ module SpeckleConnector
           mesh_layer = state.sketchup_state.sketchup_model.layers.to_a.find { |l| l.display_name == mesh['layer'] }
           added_faces.each do |face|
             face.layer = mesh_layer unless mesh_layer.nil?
+            # Smooth edges if they already soft
+            # FIXME: Below line should be reconsidered. It might be a good to know here mesh comes from NURBS or not.
+            face.edges.each { |edge| edge.smooth = true if edge.soft? } if has_any_non_planar_quad_mesh
             unless mesh['sketchup_attributes'].nil?
               SketchupModel::Dictionary::BaseDictionaryHandler
                 .attribute_dictionaries_to_native(face, mesh['sketchup_attributes']['dictionaries'])

speckle_connector/src/speckle_objects/gis/polygon_element.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../base'
+require_relative '../other/transform'
+require_relative '../other/block_definition'
+require_relative '../other/block_instance'
+require_relative '../../constants/type_constants'
+require_relative '../../sketchup_model/dictionary/dictionary_handler'
+
+module SpeckleConnector
+  module SpeckleObjects
+    module GIS
+      # BoundingBox object definition for Speckle.
+      class PolygonElement < Base
+        SPECKLE_TYPE = OBJECTS_GIS_POLYGONELEMENT
+
+        def self.get_definition_name(obj, attributes)
+          return obj['name'] unless obj['name'].nil?
+
+          return attributes['name'] unless attributes['name'].nil?
+
+          return "def::#{obj['id']}"
+        end
+
+        def self.get_qgis_attributes(obj)
+          attributes = obj['attributes'].to_h
+          speckle_properties = %w[id speckle_type totalChildrenCount units applicationId]
+          speckle_properties.each { |key| attributes.delete(key) }
+          attributes
+        end
+
+        # Handles polygon element differently from display value.
+        def self.to_native(state, obj, entities, &convert_to_native)
+          attributes = get_qgis_attributes(obj)
+          obj = collect_definition_geometries(obj)
+          obj['name'] = get_definition_name(obj, attributes)
+
+          state, _definitions = Other::BlockDefinition.to_native(
+            state,
+            obj,
+            entities,
+            &convert_to_native
+          )
+
+          definition = state.sketchup_state.sketchup_model
+                            .definitions[Other::BlockDefinition.get_definition_name(obj)]
+
+          Other::BlockInstance.find_and_erase_existing_instance(definition, obj['id'], obj['applicationId'])
+          t_arr = obj['transform']
+          transform = t_arr.nil? ? Geom::Transformation.new : Other::Transform.to_native(t_arr, obj['units'])
+          instance = entities.add_instance(definition, transform)
+          instance.name = obj['name'] unless obj['name'].nil?
+          SketchupModel::Dictionary::DictionaryHandler.set_hash(instance, attributes, 'qgis')
+          SketchupModel::Dictionary::DictionaryHandler.set_hash(definition, attributes, 'qgis')
+          # Align instance axes that created from display value. (without any transform)
+          Other::BlockInstance.align_instance_axes(instance)
+          return state, [instance, definition]
+        end
+
+        def self.collect_definition_geometries(obj)
+          geometries = []
+
+          # FIXME: This type check needed because of QGIS. It can send geometries both way, object or array..
+          #  This is something need to be fixed by QGIS.
+          if obj['geometry'].is_a?(Array)
+            obj['geometry'].each do |geometry|
+              display_value = geometry['displayValue']
+
+              geometries += display_value
+            end
+          else
+            geometries += obj['geometry']['displayValue']
+          end
+
+          geometries.each do |geo|
+            if geo['speckle_type'] && geo['speckle_type'] == OBJECTS_GEOMETRY_MESH
+              geo['sketchup_attributes'] = { 'is_soften' => false }
+            end
+          end
+
+          obj['geometry'] = geometries
+          obj
+        end
+      end
+    end
+  end
+end

speckle_connector/src/speckle_objects/other/block_definition.rb

@@ -107,16 +107,10 @@ module SpeckleConnector
           application_id = definition_obj['applicationId']
           definition = sketchup_model.definitions[definition_name]
 
-          # It is important check for hosted elements that wrapped into component in sketchup.
-          # Their definition name might be stay same but their speckle ids should be checked
-          # to compare they updated or not.
-          children_changed = false
-          unless definition.nil?
-            previous_speckle_id = definition.get_attribute(SPECKLE_BASE_OBJECT, 'speckle_id')
-            children_changed = previous_speckle_id != definition_obj['id']
-          end
+          # Check any entities of definition changed
+          entities_updated = entities_updated?(definition, definition_obj)
 
-          if definition && !children_changed &&
+          if definition && !entities_updated &&
              (definition.name == definition_name || definition.guid == application_id)
             return state, [definition]
           end
@@ -216,6 +210,19 @@ module SpeckleConnector
           new_speckle_state
         end
         # rubocop:enable Metrics/ParameterLists
+
+        # It is important check for hosted elements that wrapped into component in sketchup.
+        # Their definition name might be stay same but their speckle ids should be checked
+        # to compare they updated or not.
+        def self.entities_updated?(definition, speckle_definition)
+          children_changed = false
+          unless definition.nil?
+            # TODO: Here we need to check later if definition invalid or not.
+            previous_speckle_id = definition.get_attribute(SPECKLE_BASE_OBJECT, 'speckle_id')
+            children_changed = previous_speckle_id != speckle_definition['id']
+          end
+          children_changed
+        end
       end
     end
   end

speckle_connector/src/speckle_objects/other/block_instance.rb

@@ -131,7 +131,8 @@ module SpeckleConnector
                             .definitions[BlockDefinition.get_definition_name(block_definition)]
 
           block_layer = state.sketchup_state.sketchup_model.layers.to_a.find { |l| l.display_name == block['layer'] }
-          return add_instance_from_definition(state, block, block_layer, entities, definition, is_group, &convert_to_native)
+          return add_instance_from_definition(state, block, block_layer, entities, definition, is_group,
+                                              &convert_to_native)
         end
 
         def self.get_transform_matrix(block)

speckle_connector/src/speckle_objects/other/display_value.rb

@@ -63,7 +63,7 @@ module SpeckleConnector
           instance = entities.add_instance(definition, transform)
           instance.name = obj['name'] unless obj['name'].nil?
           # Align instance axes that created from display value. (without any transform)
-          BlockInstance.align_instance_axes(instance)
+          # BlockInstance.align_instance_axes(instance)
           return state, [instance, definition]
         end
 

speckle_connector/src/speckle_objects/relations/layer.rb

@@ -10,6 +10,7 @@ module SpeckleConnector
       class Layer < Base
         SPECKLE_TYPE = 'Speckle.Core.Models.Collection'
 
+        # rubocop:disable Metrics/ParameterLists
         def initialize(name:, visible:, is_folder:, color: nil, layers_and_folders: [], application_id: nil)
           super(
             speckle_type: SPECKLE_TYPE,
@@ -24,6 +25,7 @@ module SpeckleConnector
           self[:collectionType] = 'layer'
           self[:elements] = layers_and_folders if layers_and_folders.any?
         end
+        # rubocop:enable Metrics/ParameterLists
 
         # @param speckle_layer [Object] speckle layer object.
         # @param folder [Sketchup::Layers, Sketchup::LayerFolder] folder to create layers in it.

speckle_connector/src/speckle_objects/speckle/core/models/collection.rb

@@ -2,7 +2,6 @@
 
 require_relative '../../../base'
 
-
 module SpeckleConnector
   module SpeckleObjects
     module Speckle

speckle_connector/src/speckle_objects/speckle/core/models/layer_collection.rb

@@ -12,6 +12,7 @@ module SpeckleConnector
           # LayerCollection object that collect other speckle objects under it's elements.
           class LayerCollection < Collection
             SPECKLE_TYPE = 'Speckle.Core.Models.Collection'
+            # rubocop:disable Metrics/ParameterLists
             def initialize(name:, visible:, is_folder:, color: nil, elements: [], application_id: nil)
               super(
                 name: name,
@@ -23,6 +24,7 @@ module SpeckleConnector
               self[:is_folder] =  is_folder
               self[:color] = color unless color.nil?
             end
+            # rubocop:enable Metrics/ParameterLists
 
             def self.create_layer_collections(sketchup_model)
               headless_layers = sketchup_model.layers.layers.collect do |layer|
@@ -62,6 +64,7 @@ module SpeckleConnector
 
             # @param entity_layer [Sketchup::Layer] entity layer.
             # @param collection [Array] collection to search elements for entity's layer.
+            # rubocop:disable Metrics/CyclomaticComplexity
             def self.get_or_create_layer_collection(entity_layer, collection)
               folder_path = SpeckleConnector::SketchupModel::Query::Layer.path(entity_layer)
               entity_layer_path = folder_path + [entity_layer]
@@ -75,10 +78,8 @@ module SpeckleConnector
                 if collection_candidate.nil?
                   color = folder.respond_to?(:color) ? SpeckleObjects::Others::Color.to_speckle(folder.color) : nil
                   collection_candidate = LayerCollection.new(
-                    name: folder.display_name,
-                    visible: folder.visible?,
-                    is_folder: folder.is_a?(Sketchup::LayerFolder),
-                    color: color
+                    name: folder.display_name, visible: folder.visible?,
+                    is_folder: folder.is_a?(Sketchup::LayerFolder), color: color
                   )
                   # Before switching collection with the new one, we should add it to current collection's elements
                   collection[:elements].append(collection_candidate)
@@ -88,6 +89,7 @@ module SpeckleConnector
 
               collection
             end
+            # rubocop:enable Metrics/CyclomaticComplexity
           end
         end
       end