使用warpaffine对图片做常见处理

使用warpaffine处理图片

在目标检测和后续图像处理的流程中，warpAffine 是 OpenCV 提供的强大工具，常用于仿射变换操作。对于 YOLO 等目标检测模型，warpAffine 不仅适合于实现图片的 Letterbox（加黑边缩放）操作，也可以用于在识别目标后，裁剪出检测区域并进行规范化变换、旋转等操作。

通过调整仿射变换矩阵，我们可以在统一的 API 下完成多个常见的图像处理需求。这种方式特别适合于与 CUDA 加速实现的 Letterbox 代码无缝结合，从而实现不同的功能。

仿射变换矩阵设置

裁剪出来后resize

先将图片的裁剪位置的起点移动到图片的(0,0)点。对应的仿射变换矩阵为 $M_1 = \begin{bmatrix} 1 & 0 & dx \\ 0 & 1 & dy \\ 0 & 0 & 1 \end{bmatrix}$ ，其中 $dx = -x_{start}$ , $dy = -y_{start}$
对图片做scale变换。对应的仿射变换矩阵为
$M_2 = \begin{bmatrix} scale1 & 0 & 0 \\ 0 & scale2 & 0 \\ 0 & 0 & 1 \end{bmatrix}$ ，其中 $scale1 = \frac{dstw} {x_{end} - x_{start}}$ ， $scale2 = \frac{dsth} {y_{end} - y_{start}}$ ，dsth和dstw为目标图片的大小
最终的仿射变换矩阵为
$M = M_2 * M_1= \begin{bmatrix} scale1 & 0 & dx \\ 0 & scale2 & dy \\ 0 & 0 & 1 \end{bmatrix}$

直接裁剪

先将图片的裁剪位置的起点移动到图片的(0,0)点。对应的仿射变换矩阵为
$M = \begin{bmatrix} 1 & 0 & dx \\ 0 & 1 & dy \\ 0 & 0 & 1 \end{bmatrix}$ ，其中 $dx = -x_{start}$ , $dy = -y_{start}$
设置目标图片大小的宽高为框的宽高。M就是最终的仿射变换矩阵。

旋转

旋转的一般仿射变换矩阵

$\begin{bmatrix} x \\ y\\ 1 \end{bmatrix} => \begin{bmatrix} X \\ Y\\ 1 \end{bmatrix}$

$x = r*cos(\theta), y=r*sin(\theta)$

$X = r*cos(\theta+\alpha) = r*cos(\theta)*cos(\alpha) - r*sin(\theta)*sin(\alpha) = x*cos(\alpha) - y*sin(\alpha)$

$Y = r*sin(\theta+\alpha) = r*sin(\theta)*cos(\alpha) + r*cos(\theta)*sin(\alpha) = y*cos(\alpha) + x*sin(\alpha)$

$\begin{bmatrix} cos(\alpha) &-sin(\alpha) & 0 \\ sin(\alpha) &cos(\alpha) & 0 \\ 0 & 0 & 1 \end{bmatrix} * \begin{bmatrix} x \\ y \\ 1 \end{bmatrix} = \begin{bmatrix} X\\ Y\\ 1 \end{bmatrix}$

任意原点顺时针旋转仿射变换矩阵计算

中心点平移到原点
设原图的中心点为 $(c_x, c_y)$ ，其中： $c_x = \frac{w}{2}, \quad c_y = \frac{h}{2}$
对应的仿射变换矩阵为：
$M_1 = \begin{bmatrix} 1 & 0 & -c_x \\ 0 & 1 & -c_y \\ 0 & 0 & 1 \end{bmatrix}$

旋转
顺时针旋转 $theta$ 角度，相当于逆时针旋转 $-theta$ 。
对应的仿射变换矩阵为：
$M_2 = \begin{bmatrix} \cos\theta & \sin\theta & 0 \\ -\sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{bmatrix}$

旋转后向图片中心移动
图片旋转后，宽高会变化，新宽度 $w'$ 和高度 $h'$ 为：
$w' = |w \cdot \cos\theta| + |h \cdot \sin\theta|, \quad h' = |w \cdot \sin\theta| + |h \cdot \cos\theta|$
旋转后图片的新中心点为 $(c_x', c_y')$ ，其中： $c_x' = \frac{w'}{2}, \quad c_y' = \frac{h'}{2}$
对应的仿射变换矩阵为：
$M_3 = \begin{bmatrix} 1 & 0 & c_x' \\ 0 & 1 & c_y' \\ 0 & 0 & 1 \end{bmatrix}$

最终变换矩阵计算
综合变换矩阵为：
$M = M_3 \cdot M_2 \cdot M_1$
展开为：
$M = \begin{bmatrix} \cos\theta & \sin\theta & -c_x\cos\theta - c_y\sin\theta + c_x' \\ -\sin\theta & \cos\theta & c_x\sin\theta - c_y\cos\theta + c_y' \\ 0 & 0 & 1 \end{bmatrix}$

python 程序

对程序做了二次封装

现在支持

letter_box
裁剪图片
裁剪后resize图片到指定大小
裁剪后按照短边resize图片，保持宽高比
resize图片到指定大小
按照短边resize图片，保持宽高比
对图片做镜像出来，水平、垂直镜像
对图片做任意角度顺时针旋转，不丢失部分画面
归一化

import cv2
import numpy as np
from enum import Enum
from typing import List, Tuple, Union
from pydantic import BaseModel, field_validator

class NormType(Enum):
    NoneType = 0  
    MeanStd = 1
    AlphaBeta = 2

class ChannelType(Enum):
    NoneType = 0
    SwapRB = 1

class Norm(BaseModel):
    mean: List[float] = [0.0, 0.0, 0.0]
    std: List[float] = [1.0, 1.0, 1.0]
    alpha: float = 1 / 255.0
    beta: float = 0.0
    norm_type: NormType = NormType.NoneType
    channel_type: ChannelType = ChannelType.NoneType

    @field_validator("mean", "std", mode="before")
    @classmethod
    def validate_length(cls, value, field):
        """Ensure mean and std have exactly 3 elements."""
        if len(value) != 3:
            raise ValueError(f"{field.alias} must have exactly 3 elements.")
        return value

    @staticmethod
    def mean_std(mean: List[float], std: List[float], channel_type: ChannelType = ChannelType.NoneType) -> "Norm":
        return Norm(mean=mean, std=std, norm_type=NormType.MeanStd, channel_type=channel_type)

    @staticmethod
    def alpha_beta(alpha: float, beta: float, channel_type: ChannelType = ChannelType.NoneType) -> "Norm":
        return Norm(alpha=alpha, beta=beta, norm_type=NormType.AlphaBeta, channel_type=channel_type)

    @staticmethod
    def none() -> "Norm":
        return Norm()

    def __repr__(self):
        return (
            f"Norm(mean={self.mean}, std={self.std}, alpha={self.alpha}, beta={self.beta}, "
            f"norm_type={self.norm_type}, channel_type={self.channel_type})"
        )

class WarpaffineMatrix:
    def __init__(self, matrix: np.ndarray, target: Tuple[int, int]) -> None:
        self.matrix = matrix
        self.target = target

    def __repr__(self):
        return (
            f"WarpaffineMatrix(matrix={self.matrix}, target={self.target})"
        )

    def invert(self) -> np.ndarray:
        """Get the inverse of the affine transformation matrix."""
        return np.linalg.inv(np.vstack([self.matrix, [0, 0, 1]]))[:2]

    @staticmethod
    def letter_box_matrix(src: Tuple[int, int], target: Tuple[int, int]) -> "WarpaffineMatrix":
        scale = min(target[0] / src[0], target[1] / src[1])
        offset_x = (target[0] - scale * src[0]) * 0.5
        offset_y = (target[1] - scale * src[1]) * 0.5
        matrix = np.array([
            [scale, 0, offset_x],
            [0, scale, offset_y]
        ], dtype=np.float32)
        return WarpaffineMatrix(matrix=matrix, target=target)

    @staticmethod
    def resize_matrix(src: Tuple[int, int], target: Union[Tuple[int, int], int]) -> "WarpaffineMatrix":
        if isinstance(target, tuple):
            scale_x = target[0] / src[0]
            scale_y = target[1] / src[1]
            matrix = np.array([
                [scale_x, 0, 0],
                [0, scale_y, 0]
            ], dtype=np.float32)
            new_target = target
        elif isinstance(target, int):
            scale = target / min(src)
            new_width = int(src[0] * scale)
            new_height = int(src[1] * scale)
            matrix = np.array([
                [scale, 0, 0],
                [0, scale, 0]
            ], dtype=np.float32)
            new_target = (new_width, new_height)
        else:
            raise ValueError("Target must be either a tuple (width, height) or an integer for the shorter edge.")

        return WarpaffineMatrix(matrix=matrix, target=new_target)

    @staticmethod
    def crop_resize_matrix(
        start_point: Tuple[int, int],
        end_point: Tuple[int, int],
        target: Union[Tuple[int, int], int, None] = None
    ) -> "WarpaffineMatrix":
        """
        生成裁剪后并resize的仿射变换矩阵

        参数:
            start_point (Tuple[int, int]): Top-left (x, y).
            end_point (Tuple[int, int]): Bottom-right (x, y).
            target (Union[Tuple[int, int], int, None]): 
                If tuple, 使用原始的resize方法.
                If int, 使用短边resize方法,保持长宽比.
                If None, 相当于只截取

        Returns:
            WarpaffineMatrix: Affine transformation matrix and target dimensions.
        """
        crop_width = end_point[0] - start_point[0]
        crop_height = end_point[1] - start_point[1]

        if target is None:
            target_width, target_height = crop_width, crop_height
        elif isinstance(target, tuple):
            target_width, target_height = target
        elif isinstance(target, int):
            scale = target / min(crop_width, crop_height)
            target_width = int(crop_width * scale)
            target_height = int(crop_height * scale)
        else:
            raise ValueError("Target must be a tuple (width, height), an integer, or None.")

        scale_x = target_width / crop_width
        scale_y = target_height / crop_height

        matrix = np.array([
            [scale_x, 0, -start_point[0] * scale_x],
            [0, scale_y, -start_point[1] * scale_y]
        ], dtype=np.float32)

        return WarpaffineMatrix(matrix=matrix, target=(target_width, target_height))

    @staticmethod
    def flip_matrix(horizontal: bool, vertical: bool, src: Tuple[int, int]) -> "WarpaffineMatrix":
        """
        获取镜像变换矩阵 水平镜像、垂直镜像
        """
        scale_x = -1 if horizontal else 1
        scale_y = -1 if vertical else 1
        translate_x = src[0] if horizontal else 0
        translate_y = src[1] if vertical else 0
        matrix = np.array([[scale_x, 0, translate_x], [0, scale_y, translate_y]], dtype=np.float32)
        return WarpaffineMatrix(matrix=matrix, target=src)

    @staticmethod
    def rotate_matrix(src: Tuple[int, int], angle: float) -> "WarpaffineMatrix":
        """
        获取顺时针旋转任意角度的仿射变换矩阵, 图片不丢失信息

        参数：
        - src: 原始图片的宽高 (width, height)
        - angle: 旋转角度（顺时针为正，单位为度）

        返回：
        - WarpaffineMatrix: 包含旋转变换矩阵的对象
        """
        # 转换角度为弧度
        theta = np.deg2rad(angle)
        # 计算旋转矩阵的元素
        cos_theta = np.cos(theta)
        sin_theta = np.sin(theta)

        width, height = src
        center_x, center_y = width / 2, height / 2

        new_width = int(abs(width * cos_theta) + abs(height * sin_theta))
        new_height = int(abs(width * sin_theta) + abs(height * cos_theta))

        new_center_x, new_center_y = new_width / 2, new_height / 2

        i2d0 = cos_theta
        i2d1 = sin_theta
        i2d2 = - cos_theta * center_x - sin_theta * center_y + new_center_x
        i2d3 = -sin_theta
        i2d4 = cos_theta
        i2d5 = sin_theta * center_x - cos_theta * center_y + new_center_y

        # 构建仿射矩阵
        matrix = np.array([[i2d0, i2d1, i2d2], [i2d3, i2d4, i2d5]], dtype=np.float32)
        return WarpaffineMatrix(matrix=matrix, target=(new_width, new_height))

class ImageTransformer:
    @staticmethod
    def normilization(image: np.ndarray, norm: Norm) -> np.ndarray:
        image = image.astype(np.float32)
        if norm.channel_type == ChannelType.SwapRB:
            image = image[..., ::-1]  # Swap RGB to BGR or vice versa

        mean = np.array(norm.mean, dtype=np.float32)
        std = np.array(norm.std, dtype=np.float32)

        if norm.norm_type == NormType.MeanStd:
            image = (image * norm.alpha - mean) / std
        elif norm.norm_type == NormType.AlphaBeta:
            image = image * norm.alpha + norm.beta

        return image

    @staticmethod
    def transform(
        image: np.ndarray, 
        warpaffine_matrix: WarpaffineMatrix, 
        border_value: Tuple[int, int, int] = (114, 114, 114)
    ) -> np.ndarray:
        if image is None or warpaffine_matrix is None:
            raise ValueError("Input image and warpaffine_matrix cannot be None.")

        transformed_image = cv2.warpAffine(
            image,
            warpaffine_matrix.matrix,
            warpaffine_matrix.target,
            flags=cv2.INTER_LINEAR,
            borderMode=cv2.BORDER_CONSTANT,
            borderValue=border_value
        )
        return transformed_image

if __name__ == "__main__":
    image_path = "test.jpg"

    image = cv2.imread(image_path)
    h, w, _ = image.shape
    letter_box_matrix = WarpaffineMatrix.letter_box_matrix((w, h), (640, 640))
    letter_box_image  = ImageTransformer.transform(image, letter_box_matrix)
    cv2.imwrite("letter_box_image.jpg", letter_box_image)

    resize_matrix = WarpaffineMatrix.resize_matrix((w, h), (640, 640))
    resize_image  = ImageTransformer.transform(image, resize_matrix)
    cv2.imwrite("resize_image.jpg", resize_image)

    crop_matrix = WarpaffineMatrix.crop_resize_matrix((561, 397), (687, 530))
    crop_image  = ImageTransformer.transform(image, crop_matrix)
    cv2.imwrite("crop_image.jpg", crop_image)

    crop_resize_matrix = WarpaffineMatrix.crop_resize_matrix((561, 397), (687, 530), (224, 224))
    crop_resize_image  = ImageTransformer.transform(image, crop_resize_matrix)
    cv2.imwrite("crop_resize_image.jpg", crop_resize_image)

    crop_resize_short_matrix = WarpaffineMatrix.crop_resize_matrix((561, 397), (687, 530), 224)
    crop_resize_short_image  = ImageTransformer.transform(image, crop_resize_short_matrix)
    cv2.imwrite("crop_resize_short_image.jpg", crop_resize_short_image)

    # flip_matrix
    flip_matrix = WarpaffineMatrix.flip_matrix(False, True, (w, h))
    flip_image  = ImageTransformer.transform(image, flip_matrix)
    cv2.imwrite("flip_image_v.jpg", flip_image)

    flip_matrix = WarpaffineMatrix.flip_matrix(True, False, (w, h))
    flip_image  = ImageTransformer.transform(image, flip_matrix)
    cv2.imwrite("flip_image_h.jpg", flip_image)

    flip_matrix = WarpaffineMatrix.flip_matrix(True, True, (w, h))
    flip_image  = ImageTransformer.transform(image, flip_matrix)
    cv2.imwrite("flip_image_hv.jpg", flip_image)

    rotate_matrix = WarpaffineMatrix.rotate_matrix((w, h), 30)
    rotate_image  = ImageTransformer.transform(image, rotate_matrix)
    cv2.imwrite("rotate_image_30.jpg", rotate_image)

cuda 程序

仿射变换矩阵 Resize

struct ResizeMatrix 
{
    float i2d[6];  // image to dst(network), 2x3 matrix
    float d2i[6];  // dst to image, 2x3 matrix

    void compute(const std::tuple<int, int> &from, const std::tuple<int, int> &to) 
    {
        float scale_x = std::get<0>(to) / (float)std::get<0>(from);
        float scale_y = std::get<1>(to) / (float)std::get<1>(from);
        float scale = std::min(scale_x, scale_y);

        // resize 
        i2d[0] = scale;
        i2d[1] = 0;
        i2d[2] = 0;
        i2d[3] = 0;
        i2d[4] = scale;
        i2d[5] = 0;

        double D = i2d[0] * i2d[4] - i2d[1] * i2d[3];
        D = D != 0\. ? double(1.) / D : double(0.);
        double A11 = i2d[4] * D, A22 = i2d[0] * D, A12 = -i2d[1] * D, A21 = -i2d[3] * D;
        double b1 = -A11 * i2d[2] - A12 * i2d[5];
        double b2 = -A21 * i2d[2] - A22 * i2d[5];

        d2i[0] = A11;
        d2i[1] = A12;
        d2i[2] = b1;
        d2i[3] = A21;
        d2i[4] = A22;
        d2i[5] = b2;
    }
};

仿射变换矩阵裁剪后crop

struct ResizeCropMatrix 
{
    float i2d[6];  // image to dst(network), 2x3 matrix
    float d2i[6];  // dst to image, 2x3 matrix

    // 1 0 -x     sx 0  -x*sx
    // 0 1 -y  -> 0  sy -y*sy
    // 0 0 1      0  0  1
    void compute(const std::tuple<int, int> &to, 
                const std::tuple<int, int> &start, const std::tuple<int, int> &end) 
    {
        int start_x = std::get<0>(start);
        int start_y = std::get<1>(start);

        int end_x = std::get<0>(end);
        int end_y = std::get<1>(end);

        int dst_w = std::get<0>(to);
        int dst_h = std::get<1>(to);

        float scale_x = 1.0f * (end_x - start_x) / dst_w;
        float scale_y = 1.0f * (end_y - start_y) / dst_h;

        i2d[0] = scale_x;
        i2d[1] = 0;
        i2d[2] = -start_x * scale_x;
        i2d[3] = 0;
        i2d[4] = scale_y;
        i2d[5] = -start_y * scale_y;

        double D = i2d[0] * i2d[4] - i2d[1] * i2d[3];
        D = D != 0\. ? double(1.) / D : double(0.);
        double A11 = i2d[4] * D, A22 = i2d[0] * D, A12 = -i2d[1] * D, A21 = -i2d[3] * D;
        double b1 = -A11 * i2d[2] - A12 * i2d[5];
        double b2 = -A21 * i2d[2] - A22 * i2d[5];

        d2i[0] = A11;
        d2i[1] = A12;
        d2i[2] = b1;
        d2i[3] = A21;
        d2i[4] = A22;
        d2i[5] = b2;
    }
};

仿射变换矩阵 letter box

struct AffineMatrix 
{
    float i2d[6];  // image to dst(network), 2x3 matrix
    float d2i[6];  // dst to image, 2x3 matrix

    void compute(const std::tuple<int, int> &from, const std::tuple<int, int> &to) 
    {
        float scale_x = std::get<0>(to) / (float)std::get<0>(from);
        float scale_y = std::get<1>(to) / (float)std::get<1>(from);
        float scale = std::min(scale_x, scale_y);

        // letter box
        i2d[0] = scale;
        i2d[1] = 0;
        i2d[2] = -scale * std::get<0>(from) * 0.5 + std::get<0>(to) * 0.5 + scale * 0.5 - 0.5;
        i2d[3] = 0;
        i2d[4] = scale;
        i2d[5] = -scale * std::get<1>(from) * 0.5 + std::get<1>(to) * 0.5 + scale * 0.5 - 0.5;

        double D = i2d[0] * i2d[4] - i2d[1] * i2d[3];
        D = D != 0\. ? double(1.) / D : double(0.);
        double A11 = i2d[4] * D, A22 = i2d[0] * D, A12 = -i2d[1] * D, A21 = -i2d[3] * D;
        double b1 = -A11 * i2d[2] - A12 * i2d[5];
        double b2 = -A21 * i2d[2] - A22 * i2d[5];

        d2i[0] = A11;
        d2i[1] = A12;
        d2i[2] = b1;
        d2i[3] = A21;
        d2i[4] = A22;
        d2i[5] = b2;
    }
};

根据仿射变换矩阵变换图片的cuda程序

static __global__ void warp_affine_bilinear_and_normalize_plane_kernel(
    uint8_t *src, int src_line_size, int src_width, int src_height, float *dst, int dst_width,
    int dst_height, uint8_t const_value_st, float *warp_affine_matrix_2_3) 
{
    int dx = blockDim.x * blockIdx.x + threadIdx.x;
    int dy = blockDim.y * blockIdx.y + threadIdx.y;
    if (dx >= dst_width || dy >= dst_height) return;

    float m_x1 = warp_affine_matrix_2_3[0];
    float m_y1 = warp_affine_matrix_2_3[1];
    float m_z1 = warp_affine_matrix_2_3[2];
    float m_x2 = warp_affine_matrix_2_3[3];
    float m_y2 = warp_affine_matrix_2_3[4];
    float m_z2 = warp_affine_matrix_2_3[5];

    float src_x = m_x1 * dx + m_y1 * dy + m_z1;
    float src_y = m_x2 * dx + m_y2 * dy + m_z2;
    float c0, c1, c2;

    if (src_x <= -1 || src_x >= src_width || src_y <= -1 || src_y >= src_height) 
    {
        // out of range
        c0 = const_value_st;
        c1 = const_value_st;
        c2 = const_value_st;
    } 
    else 
    {
        int y_low = floorf(src_y);
        int x_low = floorf(src_x);
        int y_high = y_low + 1;
        int x_high = x_low + 1;

        uint8_t const_value[] = {const_value_st, const_value_st, const_value_st};
        float ly = src_y - y_low;
        float lx = src_x - x_low;
        float hy = 1 - ly;
        float hx = 1 - lx;
        float w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx;
        uint8_t *v1 = const_value;
        uint8_t *v2 = const_value;
        uint8_t *v3 = const_value;
        uint8_t *v4 = const_value;
        if (y_low >= 0) 
        {
            if (x_low >= 0) v1 = src + y_low * src_line_size + x_low * 3;

            if (x_high < src_width) v2 = src + y_low * src_line_size + x_high * 3;
        }

        if (y_high < src_height) 
        {
            if (x_low >= 0) v3 = src + y_high * src_line_size + x_low * 3;

            if (x_high < src_width) v4 = src + y_high * src_line_size + x_high * 3;
        }

        // same to opencv
        c0 = floorf(w1 * v1[0] + w2 * v2[0] + w3 * v3[0] + w4 * v4[0] + 0.5f);
        c1 = floorf(w1 * v1[1] + w2 * v2[1] + w3 * v3[1] + w4 * v4[1] + 0.5f);
        c2 = floorf(w1 * v1[2] + w2 * v2[2] + w3 * v3[2] + w4 * v4[2] + 0.5f);
    }

    int area = dst_width * dst_height;
    float *pdst_c0 = dst + dy * dst_width + dx;
    float *pdst_c1 = pdst_c0 + area;
    float *pdst_c2 = pdst_c1 + area;
    *pdst_c0 = c0;
    *pdst_c1 = c1;
    *pdst_c2 = c2;
}

最后编辑于：2024.11.21 16:29:56

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,214评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,307评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,543评论 0赞 341
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,221评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,224评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,007评论 1赞 284
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,313评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,956评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,441评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,925评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,018评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,685评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,234评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,240评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,464评论 1赞 261
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,467评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,762评论 2赞 345