let readheight: cgfloat = targetheight / scalefactor

        let readwidth: cgfloat = targetwidth / scalefactor

        let readpoint: cgpoint = cgpoint(x: widthfactor > heightfactor ? 0 : (width - readwidth) * 0.5,

                                         y: widthfactor < heightfactor ? 0 : (height - readheight) * 0.5)

 

 

 

        let newimage: nsimage = nsimage(size: targetsize)

        let thumbnailrect: cgrect = cgrect(x: 0, y: 0, width: targetsize.width, height: targetsize.height)

        let imagerect: nsrect = nsrect(x: readpoint.x, y: readpoint.y, width: readwidth, height: readheight)

 

        newimage.lockfocus()

        sourceimage.draw(in: thumbnailrect, from: imagerect, operation: .copy, fraction: 1.0)

        newimage.unlockfocus()

 

        return newimage;

    }

 

    // 等比縮放

    func resizeimage2(sourceimage: nsimage, forsize targetsize: cgsize) -> nsimage {

 

        let imagesize: cgsize = sourceimage.size

        let width: cgfloat = imagesize.width

        let height: cgfloat = imagesize.height

        let targetwidth: cgfloat = targetsize.width

        let targetheight: cgfloat = targetsize.height

        var scalefactor: cgfloat = 0.0

        var scaledwidth: cgfloat = targetwidth

        var scaledheight: cgfloat = targetheight

        var thumbnailpoint: cgpoint = cgpoint(x: 0.0, y: 0.0)

 

        if __cgsizeequaltosize(imagesize, targetsize) == false {

            let widthfactor: cgfloat = targetwidth / width

            let heightfactor:  cgfloat = targetheight / height

 

            // scale to fit the longer

            scalefactor = (widthfactor > heightfactor) ? widthfactor : heightfactor

            scaledwidth  = ceil(width * scalefactor)

            scaledheight = ceil(height * scalefactor)

 

            // center the image

            if (widthfactor > heightfactor) {

                thumbnailpoint.y = (targetheight - scaledheight) * 0.5

            } else if (widthfactor < heightfactor) {

                thumbnailpoint.x = (targetwidth - scaledwidth) * 0.5

            }

        }

 

        let newimage: nsimage = nsimage(size: nssize(width: scaledwidth, height: scaledheight))

        let thumbnailrect: cgrect = cgrect(x: thumbnailpoint.x, y: thumbnailpoint.y, width: scaledwidth, height: scaledheight)

        let imagerect: nsrect = nsrect(x: 0.0, y:0.0, width: width, height: height)

 

        newimage.lockfocus()

        sourceimage.draw(in: thumbnailrect, from: imagerect, operation: .copy, fraction: 1.0)

        newimage.unlockfocus()

 

        return newimage;

    }

 

    // 將圖片壓縮到指定大小（kb）

    func compressimgdata(imgdata: nsdata, toaimkb aimkb: nsinteger) -> nsdata? {

 

        let aimrate: cgfloat = cgfloat(aimkb * 1000) / cgfloat(imgdata.length)

 

        let imagerep: nsbitmapimagerep = nsbitmapimagerep(data: imgdata as data)!

        guard let data: data = imagerep.representation(using: .jpeg, properties:[.compressionfactor:aimrate]) else { return nil }

 

        print("數(shù)據(jù)最終大小：\(cgfloat(data.count) / 1000)， 壓縮比率：\(cgfloat(data.count) / cgfloat(imgdata.length))")

 

        return data as nsdata

    }

 

    // 組合圖片

    func jointedimagewithimages(imgarray: [nsimage]) -> nsimage {

 

        var imgw: cgfloat = 0

        var imgh: cgfloat = 0

        for img in imgarray {

            imgw += img.size.width;

            if (imgh < img.size.height) {

                imgh = img.size.height;

            }

        }

 

        print("size : \(nsstringfromsize(nssize(width: imgw, height: imgh)))")

 

        let togetherimg: nsimage = nsimage(size: nssize(width: imgw, height: imgh))

 

        togetherimg.lockfocus()

 

        let imgcontext: cgcontext? = nsgraphicscontext.current?.cgcontext

 

        var imgx: cgfloat = 0

        for imgitem in imgarray {

            if let img = imgitem as? nsimage {

                let imageref: cgimage = self.getcgimagereffromnsimage(image: img)!

                imgcontext?.draw(imageref, in: nsrect(x: imgx, y: 0, width: img.size.width, height: img.size.height))

 

            imgx += img.size.width;

            }

        }

 

        togetherimg.unlockfocus()

 

        return togetherimg;

 

    }

 

    // nsimage轉(zhuǎn)cgimageref

    func getcgimagereffromnsimage(image: nsimage) -> cgimage? {

 

        let imagedata: nsdata? = image.tiffrepresentation as nsdata?

        var imageref: cgimage? = nil

        if(imagedata != nil) {

            let imagesource: cgimagesource = cgimagesourcecreatewithdata(imagedata! as cfdata, nil)!

 

            imageref = cgimagesourcecreateimageatindex(imagesource, 0, nil)

        }

        return imageref;

    }

    

    // cgimage 轉(zhuǎn) nsimage

    func getnsimagewithcgimageref(imageref: cgimage) -> nsimage? {

 

        return nsimage(cgimage: imageref, size: nssize(width: imageref.width, height: imageref.height))

//        var imagerect: nsrect = nsrect(x: 0, y: 0, width: 0, height: 0)

//

//        var imagecontext: cgcontext? = nil

//        var newimage: nsimage? = nil

//

//        imagerect.size.height = cgfloat(imageref.height)

//        imagerect.size.width = cgfloat(imageref.width)

//

//        // create a new image to receive the quartz image data.

//        newimage = nsimage(size: imagerect.size)

//

//        newimage?.lockfocus()

//        // get the quartz context and draw.

//        imagecontext = nsgraphicscontext.current?.cgcontext

//        imagecontext?.draw(imageref, in: imagerect)

//        newimage?.unlockfocus()

//

//        return newimage;

    }

    

    // nsimage轉(zhuǎn)ciimage

    func getciimagewithnsimage(image: nsimage) -> ciimage?{

 

        // convert nsimage to bitmap

        guard let imagedata = image.tiffrepresentation,

              let imagerep = nsbitmapimagerep(data: imagedata) else { return nil }

 

        // create ciimage from imagerep

        let ciimage: ciimage = ciimage(bitmapimagerep: imagerep)!

 

        // create affine transform to flip ciimage

        let affinetransform: nsaffinetransform = nsaffinetransform()

        affinetransform.translatex(by: 0, yby: 128)

        affinetransform.scalex(by: 1, yby: -1)

 

        // create cifilter with embedded affine transform

        let transform:cifilter = cifilter(name: "ciaffinetransform")!

        transform.setvalue(ciimage, forkey: "inputimage")

        transform.setvalue(affinetransform, forkey: "inputtransform")

 

        // get the new ciimage, flipped and ready to serve

        let result: ciimage? = transform.value(forkey: "outputimage") as? ciimage

        return result;

    }

}