//  [python]
def call(self, inputs):
        '''
        输入参数 Inputs:
        -ROIboxes(RPN结果): [batch, num_boxes, 4]，4：(y1, x1, y2, x2)。nms后得锚点坐标.num_boxes=1000
        - image_meta: [batch, (meta data)] 图片的附加信息 93
        - Feature maps: [P2, P3, P4, P5]骨干网经过fpn后的特征.每个[batch, height, width, channels]
        [(1, 256, 256, 256),(1, 128, 128, 256),(1, 64, 64, 256),(1, 32, 32, 256)]
        '''
        #获取输入参数
        ROIboxes = inputs[0]#(1, 1000, 4) 
        image_meta = inputs[1]#(1, 93)
        feature_maps = inputs[2:]

        #将锚点坐标提出来
        y1, x1, y2, x2 = tf.split(ROIboxes, 4, axis=2)#[batch, num_boxes, 4]
        h = y2 - y1
        w = x2 - x1

        
        ###############################在这1000个ROI里，按固定算法匹配到不同level的特征。
        #获得图片形状
        image_shape = parse_image_meta_graph(image_meta)['image_shape'][0]
        image_area = tf.cast(image_shape[0] * image_shape[1], tf.float32)
        #因为h与w是标准化坐标。其分母已经被除了tf.sqrt(image_area)。
        #这里再除以tf.sqrt(image_area)分之1，是为了变为像素坐标
        roi_level = self.log2_graph(tf.sqrt(h * w) / (224.0 / tf.sqrt(image_area)))
        roi_level = tf.minimum(5, tf.maximum( 2, 4 + tf.cast(tf.round(roi_level), tf.int32)))
        roi_level = tf.squeeze(roi_level, 2)

        # 每个roi按照自己的区域去对应的特征里截取内容，并resize成指定的7*7大小. P2 to P5.
        pooled = []
        box_to_level = []
        for i, level in enumerate(range(2, 6)):
            #equal会返回一个true false的（1，1000），where返回其中为true的索引[[0,1],[0,4],,,[0,200]]
            ix = tf.where(tf.equal(roi_level, level),name="ix")#(828, 2)

            
            #在多维上建立索引取值[?,4](828, 4)
            level_boxes = tf.gather_nd(ROIboxes, ix,name="level_boxes")#在(1, 1000, 4)上按照[[0,1],[0,4],,,[0,200]]取值 

            # Box indices for crop_and_resize.
            box_indices = tf.cast(ix[:, 0], tf.int32)#(828, )，【0，0，0，0，0，】如果批次为2，就是[000...111]

            # Keep track of which box is mapped to which level
            box_to_level.append(ix)

            #下面两个值，是ROIboxes中按照不同尺度划分好的索引，对于该尺度特征中的批次索引，不希望有变化。所以停止梯度
            level_boxes = tf.stop_gradient(level_boxes)
            box_indices = tf.stop_gradient(box_indices)


            #结果: [batch * num_boxes, pool_height, pool_width, channels]
            #feature_maps [(1, 256, 256, 256),(1, 128, 128, 256),(1, 64, 64, 256),(1, 32, 32, 256)]
            #box_indices一共level_boxes个。指定level_boxes中的第几个框，作用于feature_maps中的第几个图片
            pooled.append(tf.image.crop_and_resize(
                feature_maps[i], level_boxes, box_indices, self.pool_shape, method="bilinear"))

        #1000个roi都取到了对应的内容，将它们组合起来。( 1000, 7, 7, 256) 
        pooled = tf.concat(pooled, axis=0)#其中的顺序是按照level来的需要重新排列成原来ROIboxes顺序

        #重新排列成原来ROIboxes顺序
        box_to_level = tf.concat(box_to_level, axis=0)#按照选取level的顺序
        box_range = tf.expand_dims(tf.range(tf.shape(box_to_level)[0]), 1)
        box_to_level = tf.concat([tf.cast(box_to_level, tf.int32), box_range],axis=1)#[1000，3] 3([xi] range)
                                 

        #取出头两个批次+序号（1000个），每个值代表原始roi展开的索引了。
        sorting_tensor = box_to_level[:, 0] * 100000 + box_to_level[:, 1] #保证一个批次在100000以内
        ix = tf.nn.top_k(sorting_tensor, k=tf.shape(#按照索引排序，
            box_to_level)[0]).indices[::-1]
        ix = tf.gather(box_to_level[:, 2], ix)#将roi中的顺序对应到pooled中的索引取出来
        pooled = tf.gather(pooled, ix)#按照索引从pooled中取出的框，就是原始顺序了。

        #加上批次维度，并返回
        pooled = tf.expand_dims(pooled, 0)#应该用reshape
        #pooled = KL.Reshape([self.batch_size,-1, self.pool_shape, self.pool_shape, mask_rcnn_model.FPN_FEATURE], name="pooled")(pooled)
        #pooled = tf.reshape(pooled, [self.batch_size,1000, self.pool_shape, self.pool_shape, mask_rcnn_model.FPN_FEATURE])
        return pooled