remove unnecessary void conversion; check on points list len before checking the first; MultiPoint naming; multiband renderer fixed;

README.md

@@ -56,7 +56,7 @@ This repo contains the QGIS plugin for Speckle 2.0. It is written in `python` an
 > The following geometry types are supported for now:
 >
 > - Point
-> - Multipoint
+> - MultiPoint
 > - Polyline (LineString)
 > - MultiLineString
 > - Polygon

speckle/converter/geometry/polygon.py

@@ -63,9 +63,9 @@ def polygonToSpeckleMesh(
             voids = []
             voidsAsPts = []
 
-            for v in voidsNative:
+            for v_speckle in voidsNative:
                 pts_fixed = []
-                v_speckle = unknownLineToSpeckle(v, True, feature, layer, dataStorage)
+                #v_speckle = unknownLineToSpeckle(v, True, feature, layer, dataStorage)
                 pts = speckleBoundaryToSpecklePts(v_speckle, dataStorage)
 
                 plane_pts = [
@@ -223,9 +223,9 @@ def polygonToSpeckle(
         voids = []
         voidsAsPts = []
 
-        for v in voidsNative:
+        for v_speckle in voidsNative:
             pts_fixed = []
-            v_speckle = unknownLineToSpeckle(v, True, feature, layer, dataStorage)
+            #v_speckle = unknownLineToSpeckle(v, True, feature, layer, dataStorage)
             pts = speckleBoundaryToSpecklePts(v_speckle, dataStorage)
 
             plane_pts = [

speckle/converter/geometry/polyline.py

@@ -69,7 +69,7 @@ def polylineFromVerticesToSpeckle(
         else:
             return None
 
-        if specklePts[0] is None:
+        if len(specklePts)==0 or specklePts[0] is None:
             logToUser("Polyline conversion failed", level=2)
             return
 
@@ -99,7 +99,7 @@ def polylineFromVerticesToSpeckle(
 
 
 def unknownLineToSpeckle(
-    poly: "QgsCompoundCurve",
+    poly: Union["QgsLineString", "QgsCompoundCurve"],
     closed: bool,
     feature: "QgsFeature",
     layer: "QgsVectorLayer",
@@ -315,7 +315,7 @@ def arcToSpeckle(
         arc.plane = Plane()
         arc.plane.origin = Point.from_list(center)
         arc.units = "m"
-        arc.plane.normal = getArcNormal(arc, arc.midPoint)
+        arc.plane.normal = getArcNormal(arc, arc.midPoint, dataStorage)
         arc.plane.origin.units = "m"
         arc.radius = radius
         arc.angleRadians, startAngle, endAngle = getArcRadianAngle(arc)
@@ -379,12 +379,11 @@ def polylineToNative(poly: Polyline, dataStorage) -> "QgsLineString":
         elif isinstance(poly, Ellipse):
             return ellipseToNative(poly, dataStorage)
 
-        if poly.closed is False:
+        if isinstance(poly, Polyline) and poly.closed is False:
             polyline = QgsLineString(
                 [pointToNative(pt, dataStorage) for pt in poly.as_points()]
             )
-            # return polyline
-        else:
+        else: # Line or open Polyline 
             ptList = poly.as_points()
             ptList.append(ptList[0])
             polyline = QgsLineString([pointToNative(pt, dataStorage) for pt in ptList])

speckle/converter/layers/layer_conversions.py

@@ -1559,8 +1559,8 @@ def vectorLayerToNative(
             geomType = "MultiPolygon"
         elif geomType == "Polyline":
             geomType = "MultiLineString"
-        elif geomType == "Multipoint":
-            geomType = "Point"
+        elif geomType.lower() == "multipoint":
+            geomType = "MultiPoint"
         elif geomType == "MultiPatch":
             geomType = "Polygon"
 
@@ -1613,7 +1613,7 @@ def addVectorMainThread(obj: Tuple):
             dataStorage.current_layer_crs_offset_x = layer.crs.offset_x
             dataStorage.current_layer_crs_offset_y = layer.crs.offset_y
             dataStorage.current_layer_crs_rotation = layer.crs.rotation
-        except Exception as e:
+        except AttributeError as e:
             print(e)
 
         project: QgsProject = plugin.dataStorage.project
@@ -1932,7 +1932,7 @@ def addRasterMainThread(obj: Tuple):
             plugin.dataStorage.current_layer_crs_offset_x = layer.crs.offset_x
             plugin.dataStorage.current_layer_crs_offset_y = layer.crs.offset_y
             plugin.dataStorage.current_layer_crs_rotation = layer.crs.rotation
-        except Exception as e:
+        except AttributeError as e:
             print(e)
 
         shortName = newName.split(SYMBOL)[len(newName.split(SYMBOL)) - 1][:50]
@@ -2123,7 +2123,7 @@ def addRasterMainThread(obj: Tuple):
                 dataStorage.current_layer_crs_offset_y
             ) = dataStorage.current_layer_crs_rotation = None
 
-        except Exception as e:
+        except AttributeError as e:
             print(e)
         xform = QgsCoordinateTransform(crs, crsRaster, project)
         pt.transform(xform)

speckle/converter/layers/symbology.py

@@ -373,15 +373,15 @@ def rasterRendererToNative(
         if renderer and renderer["type"]:
             if renderer["type"] == "singlebandgray":
                 band = renderer["properties"]["band"]
+                rendererNew = QgsSingleBandGrayRenderer(rInterface, int(band))
                 contrast = QgsContrastEnhancement()
                 contrast.setContrastEnhancementAlgorithm(
                     int(renderer["properties"]["contrast"])
                 )
+                rendererNew.setContrastEnhancement(contrast)
                 contrast.setMaximumValue(float(renderer["properties"]["max"]))
                 contrast.setMinimumValue(float(renderer["properties"]["min"]))
-
-                rendererNew = QgsSingleBandGrayRenderer(rInterface, int(band))
-                rendererNew.setContrastEnhancement(contrast)
+                # rendererNew.setContrastEnhancement(contrast)
 
             if renderer["type"] == "multibandcolor":
                 redBand = renderer["properties"]["redBand"]
@@ -395,6 +395,7 @@ def rasterRendererToNative(
                     contrastR.setContrastEnhancementAlgorithm(
                         int(renderer["properties"]["redContrast"])
                     )
+                    rendererNew.setRedContrastEnhancement(contrastR)
                     contrastR.setMaximumValue(float(renderer["properties"]["redMax"]))
                     contrastR.setMinimumValue(float(renderer["properties"]["redMin"]))
                     # rendererNew.setRedContrastEnhancement(contrastR)
@@ -405,6 +406,7 @@ def rasterRendererToNative(
                     contrastG.setContrastEnhancementAlgorithm(
                         int(renderer["properties"]["greenContrast"])
                     )
+                    rendererNew.setGreenContrastEnhancement(contrastG)
                     contrastG.setMaximumValue(float(renderer["properties"]["greenMax"]))
                     contrastG.setMinimumValue(float(renderer["properties"]["greenMin"]))
                     # rendererNew.setGreenContrastEnhancement(contrastG)
@@ -415,6 +417,7 @@ def rasterRendererToNative(
                     contrastB.setContrastEnhancementAlgorithm(
                         int(renderer["properties"]["blueContrast"])
                     )
+                    rendererNew.setBlueContrastEnhancement(contrastB)
                     contrastB.setMaximumValue(float(renderer["properties"]["blueMax"]))
                     contrastB.setMinimumValue(float(renderer["properties"]["blueMin"]))
                     # rendererNew.setBlueContrastEnhancement(contrastB)

speckle/converter/layers/utils.py

@@ -89,13 +89,13 @@ def getLayerGeomType(
             return "PolygonZM"
 
         elif layer.wkbType() == 4:
-            return "Multipoint"
+            return "MultiPoint"
         elif layer.wkbType() == 2004:
-            return "MultipointM"
+            return "MultiPointM"
         elif layer.wkbType() == 1004:
-            return "MultipointZ"
+            return "MultiPointZ"
         elif layer.wkbType() == 3004:
-            return "MultipointZM"
+            return "MultiPointZM"
 
         elif layer.wkbType() == 5:
             return "MultiLineString"
@@ -107,13 +107,13 @@ def getLayerGeomType(
             return "MultiLineStringZM"
 
         elif layer.wkbType() == 6:
-            return "Multipolygon"
+            return "MultiPolygon"
         elif layer.wkbType() == 2006:
-            return "MultipolygonM"
+            return "MultiPolygonM"
         elif layer.wkbType() == 1006:
-            return "MultipolygonZ"
+            return "MultiPolygonZ"
         elif layer.wkbType() == 3006:
-            return "MultipolygonZM"
+            return "MultiPolygonZM"
 
         elif layer.wkbType() == 7:
             return "GeometryCollection"

tests/unit/features_tests/test_feature_utils.py

@@ -23,4 +23,5 @@ def test_addFeatVariant(qgis_feature):
     variant = 10 # string
     value = "value to add"
     result = addFeatVariant(key, variant, value, qgis_feature)
-    assert isinstance(result, QgsFeature)
+    assert isinstance(result, QgsFeature)
+