Python voidptr示例

 def read_image_file_into_qpixmap_item(cls, im_fpath, qpixmap_item, required_size=None):
     im = cls.normalize_intensity(freeimage.read(str(im_fpath)))
     qim = Qt.QImage(sip.voidptr(im.ctypes.data), im.shape[0], im.shape[1], Qt.QImage.Format_RGB888)
     if required_size is not None and qim.size() != required_size:
         raise ValueError('Expected {}x{} image, but "{}" is {}x{}.'.format(required_size.width(), required_size.height(), str(im_fpath), qim.size().width(), qim.size().height()))
     qpixmap_item.setPixmap(Qt.QPixmap(qim))

def extract(image, maxDiff, rgb, minSize):
    return _extractor.extract(sip.voidptr(sip.unwrapinstance(image)), maxDiff,
                              rgb, minSize)

def to_img_fast( img, scalar_type=None, lut=None, forceNativeLut=False):
    """Transform an image array into a QImage.
    The implementation tries to minimize data copies and casting by
    determining the exact flags for QImage and feeding it with the
    data pointer.
    :Returns Type: QImage
    import sip
    l_sh = len(img.shape)
    if l_sh == 3:
        vdim = img.shape[2]
        img = img.transpose(1,0,2)
    elif l_sh == 4:
        vdim = img.shape[3]
        img = img.transpose(1,0,0,2)
    elif l_sh == 2:
        vdim = 1
        img = img.transpose(1,0)
    else:
        raise Exception("Unknown image shape, cannot deduce pixel format")
    if vdim == 1: # : We are working on scalar images, this includes argb32 encoded images
        if scalar_type == None:
            # -- make sure we always have a default lut to display indexed things --
            cmax = img.max()
            if lut is None:
                lut = palette_factory("grayscale", cmax)
            # -- if all values fit within a uint8, cast and operate on it.
            # Currently doesn't work on non-square images maybe  because all
            # data is not 32bits aligned.  --
            if forceNativeLut: #cmax <= 255:
                print "using native 8bit color map"
                if img.dtype != uint8 :
                    img = uint8(img)
                qim = QImage(sip.voidptr(img.ctypes.data), img.shape[0], img.shape[1], QImage.Format_Indexed8)
                qim.setColorTable(lut.tolist())
                return qim.copy()
            else:
                # -- QImages currently only allow indexing of 8bit images (up to value 255).
                # This disqualifies anything that has cmax > 255. However, these can be handled
                # on our side by converting them to RGBA and processing them as such --
                # print "casting from indexed to argb32"
                img = lut[img] # : this creates an rgba image (len(shape)==2)
                return to_img(img, scalar_type="argb32")
        elif scalar_type=="argb32":
            print "using native scalar argb32"
            qim = QImage(sip.voidptr(img.ctypes.data), img.shape[0], img.shape[1], QImage.Format_ARGB32).copy()
            return qim
    elif vdim in [3,4]  : # : We are working on vectorial things like RGB ...
        data = img.ctypes.data
        if vdim == 3:
            print "using native vectorial rgb888"
            fmt = QImage.Format_RGB888
        elif vdim == 4: # ... or RGBA
            print "using native vectorial argb32"
            fmt = QImage.Format_ARGB32
        else:
            raise Exception("Unhandled vectorial pixel type")
        qim = QImage(sip.voidptr(data), img.shape[0], img.shape[1], fmt)
        return qim.copy()
    else:
        raise Exception( "Arrays of shape length %s are not handled" % l_sh )