Python cv2 模块，pyrDown() 实例源码

def genMipMap(texCube):
    #assume width = height and is 2^x
    nLevel = int(min(10, math.log(texCube.shape[1], 2))) + 1
    texMipMapList = []
    texMipMapList.append(texCube)
    for k in range(1, nLevel):
        prevCube = texMipMapList[k-1]
        if(len(prevCube.shape) == 3):
            newCube = np.ones((6, prevCube.shape[1] / 2, prevCube.shape[2] / 2))
        else:
            newCube = np.ones((6, prevCube.shape[1] / 2, prevCube.shape[2] / 2, 4))

        for f in range(0, 6):
            newCube[f] = meanDownsample(prevCube[f])#cv2.pyrDown(prevCube[f])

        texMipMapList.append(newCube.astype(np.float32))
    return texMipMapList

def features(image, channel, levels=9, start_size=(1983, 1088), ):
    """
        Extracts features by down-scaling the image levels times,
        transforms the image by applying the function channel to 
        each scaled version and computing the difference between 
        the scaled, transformed versions.
            image :         the image
            channel :       a function which transforms the image into
                            another image of the same size
            levels :        number of scaling levels
            start_size :    tuple.  The size of the biggest image in 
                            the scaling pyramid.  The image is first
                            scaled to that size and then scaled by half
                            levels times.  Therefore, both entries in
                            start_size must be divisible by 2^levels.
    """
    image = channel(image)
    if image.shape != start_size:
        image = cv2.resize(image, dsize=start_size)

    scales = [image]
    for l in xrange(levels - 1):
        logger.debug("scaling at level %d", l)
        scales.append(cv2.pyrDown(scales[-1]))

    features = []
    for i in xrange(1, levels - 5):
        big = scales[i]
        for j in (3,4):
            logger.debug("computing features for levels %d and %d", i, i + j)
            small = scales[i + j]
            srcsize = small.shape[1],small.shape[0]
            dstsize = big.shape[1],big.shape[0]
            logger.debug("Shape source: %s, Shape target :%s", srcsize, dstsize)
            scaled = cv2.resize(src=small, dsize=dstsize)
            features.append(((i+1,j+1),cv2.absdiff(big, scaled)))

    return features

def pyramid(image, minSize):
    yield image

    if image.shape[0] < minSize[0] and image.shape[1] < minSize[1]:
        # image too small - upscaling until we hit window level
        image = cv2.pyrUp(image)

        while (image.shape[0] <= minSize[0] or image.shape[1] <= minSize[1]):
            yield image
            image = cv2.pyrUp(image)
    else:
        # image too big - downscaling until we hit window level
        image = cv2.pyrDown(image)

        while (image.shape[0] >= minSize[0] or image.shape[1] >= minSize[1]):
            yield image
            image = cv2.pyrDown(image)


# Malisiewicz et al.

def render(self,frame):
        numDownSamples = 2
        img_rgb = frame
        # number of downscaling steps
        numBilateralFilters = 7
        # number of bilateral filtering steps
        # -- STEP 1 --
        # downsample image using Gaussian pyramid
        img_color = img_rgb
        for _ in xrange(numDownSamples):
            img_color = cv2.pyrDown(img_color)
        # repeatedly apply small bilateral filter instead of applying
        # one large filter
        for _ in xrange(numBilateralFilters):
            img_color = cv2.bilateralFilter(img_color, 9, 9, 7)

        # upsample image to original size
        for _ in xrange(numDownSamples):
            img_color = cv2.pyrUp(img_color)
        # convert to grayscale and apply median blur
        img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
        img_blur = cv2.medianBlur(img_gray, 7)

        # detect and enhance edges
        img_edge = cv2.adaptiveThreshold(img_blur, 255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY, 9, 2)
        # -- STEP 5 --
        # convert back to color so that it can be bit-ANDed with color image
        img_edge = cv2.cvtColor(img_edge, cv2.COLOR_GRAY2RGB)
        final = cv2.bitwise_and(img_color, img_edge)
        return cv2.medianBlur(final,7)

def render(self,frame):
        canvas = cv2.imread("pen.jpg", cv2.CV_8UC1)
        numDownSamples = 2
        img_rgb = frame
        # number of downscaling steps
        numBilateralFilters = 3
        # number of bilateral filtering steps
        # -- STEP 1 --
        # downsample image using Gaussian pyramid
        img_color = img_rgb
        for _ in xrange(numDownSamples):
            img_color = cv2.pyrDown(img_color)
        # repeatedly apply small bilateral filter instead of applying
        # one large filter
        for _ in xrange(numBilateralFilters):
            img_color = cv2.bilateralFilter(img_color, 9, 9, 3)

        # upsample image to original size
        for _ in xrange(numDownSamples):
            img_color = cv2.pyrUp(img_color)
        # convert to grayscale and apply median blur
        img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
        img_blur = cv2.medianBlur(img_gray, 3)

        # detect and enhance edges
        img_edge = cv2.adaptiveThreshold(img_blur, 255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY, 9, 2)
        return  cv2.multiply(cv2.medianBlur(img_edge,7), canvas, scale=1./256)

def doPyrDown(im):
    # Do the pyrdown by default half size
    out = cv2.pyrDown(im)
    return out

def pyrDownUp(img, times=1):
    img_temp = img
    for i in xrange(int(times)):
        img_temp = cv.pyrDown(img_temp)
    img_new = img_temp
    for i in xrange(int(times)):
        img_new = cv.pyrUp(img_new)
    return img_new

# img = cv.imread("./test.jpg")
# img_new = pyrDownUp(img, 2)
# cv.imwrite("./new.jpg", img_new)

def getRGB(self,rgb):
        self.rgb=rgb
        #self.down=cv2.pyrDown(rgb)
        self.down[:,:,:]=self.rgb[:,:,:]

        #print  self.down.shape 
        #self.down.shape=(150,200)

def _prep_topo_data(self, grid_points=100):
        """Prepare topography data for map

        This function prepares high resolution topography for plotting, i.e.
        it reduces the resolution based on the map size

        :param int grid_points: number of plotted grid points (default: 100)

        """


        if not isinstance(self.topo_data, TopoData):
            try:
                self.load_topo_data()
            except:
                raise

        topo = self.topo_data
        # determine the nu
        pyr_steps = int(ceil(log2(float(len(topo.lons)) / grid_points)))
        z_max = float(topo.max)
        z_min = float(topo.min)
        z_order = floor(log10(topo.alt_range))
        X,Y = meshgrid(topo.lons, topo.lats)
        x, y = self(X, Y)
        z = topo.data
        if not CV2_AVAILABLE:
            print ("Could not reduce resolution of topographic data, opencv "
                "library is not available")
        else:
            if pyr_steps > 0:
                for k in range(pyr_steps):
                    x = pyrDown(x)
                    y = pyrDown(y)
                    z = pyrDown(z)            
        return (x, y, z, z_min, z_max, z_order)