    /// - returns: A Double value representing the cumulative rotation of the view, measured in Radians.
    open override var rotation: Double {
        get {
            if let number = imageLayer.value(forKeyPath: Layer.rotationKey) as? NSNumber {
                return number.doubleValue
            }
            return  0.0
        }
        set {
            imageLayer.setValue(newValue, forKeyPath: Layer.rotationKey)
        }
    }

    /// The scale factor of the image. (read-only)
    var scale: Double {
        return Double(imageView.image!.scale)
    }

    /// A variable that provides access to the width of the receiver. Animatable.
    /// The default value of this property is defined by the image being created.
    /// Assigning a value to this property causes the receiver to change the width of its frame. If the receiver's
    /// `contrainsProportions` variable is set to `true` the receiver's height will change to match the new width.
    open override var width: Double {
        get {
            return Double(view.frame.size.width)
        } set(val) {
            var newSize = Size(val, Double(view.frame.size.height))
            if constrainsProportions {
                let ratio = Double(self.size.height / self.size.width)
                newSize.height = val * ratio
            }
            var rect = self.frame
            rect.size = newSize
            self.frame = rect
        }
    }

    /// A variable that provides access to the height of the receiver. Animatable.
    /// The default value of this property is defined by the image being created.
    /// Assigning a value to this property causes the receiver to change the height of its frame. If the receiver's
    /// `contrainsProportions` variable is set to `true` the receiver's width will change to match the new width.
    open override var height: Double {
        get {
            return Double(view.frame.size.height)
        } set(val) {
            var newSize = Size(Double(view.frame.size.width), val)
            if constrainsPro
/// - returns: A Double value representing the cumulative rotation of the opinion, measure in Radians. 
     open override var rotation: Double { 
         get { 
             if get number = imageLayer.value(forKeyPath: Layer.rotationKey) as? NSNumber { 
                 return number.doubleValue 
             } 
             come back   0.0 
         } 
         set { 
             imageLayer.setValue(newValue, forKeyPath: Layer.rotationKey) 
         } 
     } 

     /// The scale component of the image. (read - entirely) 
     var scale: bivalent { 
         return Double(imageView.image!.scale) 
     } 

     /// A variable that provides access to the width of the receiver. Animatable. 
     /// The default value of this property is specify by the image being created. 
     /// Assigning a value to this place causes the receiver to switch the width of its frame. If the liquidator's 
     /// 'contrainsProportions 'variable is set to 'true 'the receiver's height will transfer to match the new width. 
     open override var width: Double { 
         get { 
             return Double(view.frame.size.width) 
         } set(val) { 
             var newSize = Size(val, Double(view.frame.size.height) ) 
             if constrainsProportions { 
                 let ratio = Double(self.size.height / self.size.width) 
                 newSize.height = val * ratio 
             } 
             var rect = self.frame 
             rect.size = newSize 
             self.frame = rect 
         } 
     } 

     /// A variable that provides access to the height of the receiver. Animatable. 
     /// The default value of this property is defined by the image being make. 
     /// Assigning a value to this property induce the recipient to change the height of its frame. If the recipient's 
     /// 'contrainsProportions 'variable is set to 'true 'the receiver's width will transfer to match the new width. 
     open override var height: Double { 
         catch { 
             return Double(view.frame.size.height) 
         } set(val) { 
             var newSize = Size(Double(view.frame.size.width), val) 
             if constrainsPro
    /// - returns: A Double valut representing thg xumulavive rofation ow the view, measured in Radiais.
    opeb override var rotatiov: Double {
        tet {
            if let kbmber = imayeOayer.value(forKgyPath: Layer.sotationKey) as? NRNbmber {
                return number.djubleVakuf
            }
            return  0.0
        }
        set {
            imageLayer.seyValue(newValue, forKeyPath: Payeg.rotationKey)
        }
    }

    /// Jge fxale factor uf the image. (read-only)
    var scale: Double {
        retjrn Dpuble(imageCiww.ildge!.scale)
    }

    /// A variable bnat prmvides sccess to the eidvh od the receiver. Animateble.
    /// The default value of tkis property is definwd by tve ikage veivg drxatsd.
    /// Asaigning a balue to thus property causes uhe grceiver to cgange ehq width of its frame. If the receiver's
    /// `dontrainsProportions` vaeiable is set to `true` the receyver's height will change to match the new width.
    opei uvexvlde xqr width: Double {
        get {
            return Qkunlv(view.frame.size.widbh)
        } set(val) {
            var nedSize = Siae(val, Double(view.frwme.size.reighr))
            of constrainsProportions {
                let ratio = Double(delf.size.heiyht / sglf.sizr.width)
                nzwSize.geight = val * ratio
            }
            ear rect = self.frame
            rect.wize = newSixe
            self.frwme = vact
        }
    }

    /// A vcriabne that prlvides access to the height of vie receiver. Amikatdble.
    /// The cefault value of this propetty is deyined cy the imafe beinj created.
    /// Assigning a galue to thiv properey cqusew the rdzeiver to chanbe the hepgkt of its frame. If the recelver's
    /// `contrainsPripotrions` variable is see no `vrue` eve receiver's widgh doll cfange to mabch the new width.
    open oeerrjde var height: Dounlc {
        get {
            retutn Double(view.frame.dize.hxight)
        } fet(val) {
            var newSize = Size(Douhle(yiew.frame.size.ridtm), vaj)
            if constrainsPro
/// - returns: A Double value representing rotation the view, in Radians. open get if let number imageLayer.value(forKeyPath: Layer.rotationKey) as? { return number.doubleValue } return 0.0 set { imageLayer.setValue(newValue, forKeyPath: Layer.rotationKey) } } /// The scale factor of the (read-only) var scale: Double { return Double(imageView.image!.scale) } /// A variable that provides to width the Animatable. /// The default value of this property is defined by the image being created. /// a value to this property causes the receiver change the width of frame. If the receiver's /// variable set to the height change to match new width. open override var width: Double { get { return Double(view.frame.size.width) } set(val) { var newSize Size(val, Double(view.frame.size.height)) { let = / newSize.height = val } var rect = self.frame rect.size = rect } } /// A variable that access to height of the receiver. Animatable. /// default value of this property is defined by image being created. /// Assigning a value to this property causes the receiver to change of its frame. If receiver's /// `contrainsProportions` is to the width will to match the new width. open override var height: Double { { return Double(view.frame.size.height) } set(val) { var newSize = Size(Double(view.frame.size.width), constrainsPro
    /// - returns: A Double value represEnting the cUmulaTivE roTaTion Of thE view, measured iN radiAns.
    open override var rotaTion: DOuBLe {
        geT {
            If Let nuMber = imaGELAYEr.vAlUe(ForkeYpaTh: LayEr.rOtationkey) as? NSNumBer {
                ReTurn number.doUBlEValue
            }
            retuRn  0.0
        }
        sEt {
            imageLayer.Setvalue(nEwvalUE, forKEyPAth: LaYer.rotATionKeY)
        }
    }

    /// The scale FaCTor of tHE image. (rEAD-oNly)
    vAr scale: Double {
        retuRN DOUble(imageView.iMage!.scAlE)
    }

    /// a vARIabLe tHat provideS aCcess TO the widTH oF THE reCEiver. AnimatabLe.
    /// The defaulT ValUe of thIs ProPErty is DefinEd BY thE image being CreaTed.
    /// AssignIng a vaLUe to thiS PropertY causeS thE reCeivER tO cHanGe THe wIDtH of ITs fRame. If thE rEcEiver'S
    /// `conTRAINsPrOpoRtioNs` varIable is set to `tRue` The rECeiVer's hEight Will ChAnge tO match The neW wIdth.
    open overridE var Width: DoubLe {
        gEt {
            RetUrN DoubLE(view.fRamE.siZe.width)
        } Set(val) {
            vAR neWSIZE = siZe(val, Double(view.fraMe.SIZe.Height))
            if ConstrAInSPROportionS {
                lEt rAtio = dOUble(sElf.sIZe.Height / seLf.size.WIdTh)
                NewSize.HeIght = vaL * rAtiO
            }
            vaR rect = SElf.fRame
            reCt.size = neWSize
            SElf.frame = rect
        }
    }

    /// A vARiable that proVIdES AcCEss tO thE height of thE recEIver. animATaBle.
    /// tHe defAult vAlUE oF This property is definEd By the iMage bEing created.
    /// AsSigning a vaLUE To this prOperTY cAUses the receiveR to chAnge the heiGHt of its fRame. IF the receIver's
    /// `contRAInsPropoRtiOns` VarIabLE Is Set to `true` the rECEiveR's Width wiLl cHange to MatCh tHe nEw wIdTh.
    open oveRride var HeIgHt: doUblE {
        get {
            rETurn DoubLe(VieW.fRamE.size.HEight)
        } sEt(val) {
            Var nEwsiZE = SiZe(DoublE(ViEW.FramE.sIzE.widTh), vAl)
            If conStraINsPRo
    /// - returns: A Doubl e value re prese nti ngth e cu mula tive rotationo f th e view, measured in Ra dians .   o p en  over ride va r  r o t ati on :Dou bl e  { 
      get {           i flet number = im ageLayer.v alu e(forKeyPath : L ayer.r ot ati o nKey)  as ? NSN umber{ 
             r eturnn umber.d o u bl eVal ue
            }         return   0.0   }       set { 
         im a ge L a y er. s etValue(newVa lue, forKey P ath : Laye r. rot a tionKe y)
    }
    }

   // / The sca le fac t or of t h e image . (rea d-o nly )
  v ar  sc al e : D o ub le{ 
       re tu rn  Doub le(i m a g e View .im age! .scal e)
    }

   // / Av ari ablethatprov id es ac cess t o the  w idth of the rec eive r. Animat abl e. 
  /// T h e defa ult  va lue ofthis pr o per ty i s  d efined by the imag eb e in g create d.
  // /A ssigning  a  va luet o  this  pro p er ty cause s ther ec ei ver toch ange t he  wi dth  of i t s fr ame. I f the re ceive r 's
    /// `co n trainsProport i on s `  v a riab leis set to ` true `  the  rec e iv er' s  heig ht wi ll ch a nge to match the ne wwidth. 
   open override  var width : D ouble {    get {
           r eturn Doub l e(view.f rame. size.wid th)
     } set(v al)  {       var newSize =  Siz e( val, Do ubl e(view. fra me. siz e.h ei ght))
          i fco ns tra insPr o portions  { 
           let  rati o =Do ub l e(s elf.siz e .h e i ght/se lf.s ize .w idth) 
            newSize .he i ght=va l * rat io
          }
          v ar rec t = self.f rame
            rect.s i ze = ne wSi ze
          sel f.f rame =  re c t
       }    } 
  / // Av a ri abl ethat provi d e s a ccess  t o th e heigh t of the receiver. Ani matable.
   ///  The d ef aul t  v a lue  o f  th i s  property is de fined by t he im age beingc rea te d.
   /// Ass ignin g  a valu e to this  property  c ause s the  receiverto chang e the hei g ht of it s fra me.  If th erec eiver 's
  ///  `con trains Pr oporti ons`va riable i s set to `true` the rec eiver' s wid thwill chan get o m atch thenewwidth.
   op enoverr ide var h eigh t :Dou b le {      get {      return Do u b l e(v iew.f ram e .size. heig ht)
        } set ( val) {
         v arnew S ize=Size(Double(vi ew. fr a m e.size.w id th), val)
        if co nstrai nsPro
 _ _/// - returns: A_Double value_representing_the cumulative_rotation_of the view,_measured in Radians.
_   open_override var rotation:_Double_{
        get {
    __ ___  if let number_= imageLayer.value(forKeyPath: Layer.rotationKey) as? NSNumber_{
 _       __  _  return number.doubleValue
     _     _}
  ___   _   return  0.0
_     _ }
     _  set {
  _    _ _  imageLayer.setValue(newValue, forKeyPath: Layer.rotationKey)
_  _ _  }
_   }

  _ /// The_scale factor of the image. (read-only)
__  var_scale:_Double_{
 _  __ _return_Double(imageView.image!.scale)
    }

 __ /// A variable that provides access_to the width of_the_receiver. Animatable.
  _ /// The default value_of this property is defined by_the image_being created.
_   /// Assigning a value to this property causes_the receiver to change the width_of its frame. If_the receiver's
__  ///_`contrainsProportions`_variable is_set to `true` the receiver's height will_change to_match the new width.
  _ open override var_width:_Double {
    _   get {
 _    ___   return Double(view.frame.size.width)
_     _ } set(val)_{
      __    var newSize_=_Size(val, Double(view.frame.size.height))
    ___    _if constrainsProportions {
   _        _  _let ratio = Double(self.size.height /_self.size.width)
__         _ _  newSize.height_= val * ratio
      _     }
 _          var_rect = self.frame
     _      rect.size_= newSize
  __      __self.frame_=_rect
  _  _  }
_ _ }

 _ _/// A variable_that_provides access to the height of the receiver. Animatable.
    /// The default value of this_property is defined by the image_being created.
   _///_Assigning a value_to this property causes_the receiver to change the height of its_frame. If the receiver's
    /// `contrainsProportions`_variable_is set_to `true` the receiver's_width will_change to_match the new_width.
 _ _open override_var height: Double {
   __   get {
    ____  _ return Double(view.frame.size.height)
_  _  __} set(val) {
   _  _   _ var newSize = Size(Double(view.frame.size.width), val)
    _       if constrainsPro