     
     private var components: [Component]
     
-    public var baseTransform : SDTransform = SDTransform.identity {
+    public var transform : SDTransform = SDTransform.identity {
         willSet {
-            if baseTransform != newValue {
+            if transform != newValue {
                 cache = cache.lck.synchronized { Cache(originalBoundary: cache.originalBoundary, boundary: nil, table: cache.table) }
             }
-        }
-    }
-    
-    public var rotate: Double = 0 {
-        willSet {
-            if rotate != newValue {
-                cache = cache.lck.synchronized { Cache(originalBoundary: cache.originalBoundary, boundary: nil, table: cache.table) }
-            }
-        }
-    }
-    public var scale: Double = 1 {
-        didSet {
-            if scale != oldValue {
-                cache = cache.lck.synchronized {
-                    let boundary = cache.boundary
-                    let center = self.center
-                    let _scale = self.scale / oldValue
-                    return Cache(originalBoundary: cache.originalBoundary, boundary: boundary.map { Rect.bound($0.points.map { ($0 - center) * _scale + center }) }, table: cache.table)
-                }
-            }
-        }
-    }
-    public var transform : SDTransform {
-        get {
-            let center = self.center
-            let translate = SDTransform.translate(x: center.x, y: center.y)
-            let scale = SDTransform.scale(self.scale)
-            let rotate = SDTransform.rotate(self.rotate)
-            return baseTransform * translate.inverse * scale * rotate * translate
-        }
-        set {
-            let center = originalBoundary.center * newValue
-            let translate = SDTransform.translate(x: center.x, y: center.y)
-            let scale = SDTransform.scale(self.scale)
-            let rotate = SDTransform.rotate(self.rotate)
-            baseTransform = newValue * translate.inverse * rotate.inverse * scale.inverse * translate
         }
     }
     

    
    public var center : Point {
        get {
            return originalBoundary.center * baseTransform
        }
        set {
            let _center = center

extension Shape {
    
    public var identity : Shape {
        if transform == SDTransform.identity {
            return self
        }
        return cache.lck.synchronized {
            if cache.identity == nil {
                if transform == SDTransform.identity {
                    let _path = Shape(self.components)
                    _path.cache.originalBoundary = cache.originalBoundary
