![在这里插入图片描述](/static/img/images/03756.png)






泊松图像混合（Poisson Image Editing）的原理基于泊松方程。该方法旨在保持图像中的梯度一致性，从而在图像编辑中实现平滑和无缝的混合。以下是泊松图像混合的基本原理和公式：

### 泊松方程

泊松方程是一个偏微分方程，通常用于描述物理和数学中的一些现象。在图像处理中，泊松方程的形式如下：

\[\nabla^2 u = f\]

其中，\(\nabla^2\) 是拉普拉斯算子，\(u\) 是图像中的像素值，\(f\) 是输入图像中的梯度。

### 泊松图像混合

在图像编辑中，泊松图像混合的目标是将源图像 \(S\) 中的内容（包含一些掩码区域）融合到目标图像 \(T\) 中。设混合结果为 \(R\)。

1. **定义泊松方程**

   泊松图像混合的目标是找到一个图像 \(R\)，使得在掩码区域内，\(R\) 的梯度与源图像 \(S\) 中的梯度相匹配，并且在掩码区域外，\(R\) 等于目标图像 \(T\)。

   \[\nabla^2 R = \nabla^2 S \quad \text{在掩码区域内}\]

   \[R = T \quad \text{在掩码区域外}\]

2. **离散化泊松方程**

   将泊松方程离散化，得到以下方程：

   \[4R_{i,j} - R_{i-1,j} - R_{i+1,j} - R_{i,j-1} - R_{i,j+1} = S_{i,j} \quad \text{在掩码区域内}\]

   \[R_{i,j} = T_{i,j} \quad \text{在掩码区域外}\]

   其中，\(R_{i,j}\) 是混合图像中像素 \((i,j)\) 处的值，\(S_{i,j}\) 是源图像中像素 \((i,j)\) 处的值，\(T_{i,j}\) 是目标图像中像素 \((i,j)\) 处的值。

3. **求解泊松方程**

   这是一个线性方程组，可以通过迭代求解、矩阵求逆等方法来得到混合图像 \(R\)。

在实际应用中，为了更好地处理边界和获得高质量的混合结果，通常会采用一些改进的算法，如高斯-赛德尔方法、共轭梯度法等。

请注意，上述是泊松图像混合的基本思想和公式，实际实现可能涉及到更多的细节和优化。希望这能帮助理解泊松图像混合的原理。

什么是泊松图像混合

chrome浏览器拖拽图片到本地文件夹，名字是乱的或者重名，那么我们将之前在本地的图片都命名好，就不会存在这个问题。






用python写一个程序，不断监测C:\Users\xjsd\Desktop\outpainting_test_data内的文件名（不算后缀），如果命名不满足f0001【0001是递增的】，就将该文件名改为满足规范的（后缀保持原样）。

python

```python
import os
import re
import time
def rename_files(directory_path):
    # Get a list of existing file names in the directory
    existing_files = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f))]
    # Sort the existing file names
    existing_files.sort()
    # Initialize a counter for the new names
    counter = len(existing_files)
    # Iterate through existing files
    for filename in existing_files:
        base_name, file_extension = os.path.splitext(filename)
        # Define the expected pattern f0001
        pattern = re.compile(r'f(\d{4})')
        # Check if the current filename matches the pattern
        match = re.match(pattern, base_name)
        if not match:
            while 1:
                # If not, generate a new filename following the pattern
                new_filename = f'f{str(counter).zfill(4)}{file_extension}'
                # Update the counter
                counter += 1
                # Check if the new filename already exists
                if new_filename not in existing_files:
                    break
            # Rename the file
            old_file_path = os.path.join(directory_path, filename)
            new_file_path = os.path.join(directory_path, new_filename)
            os.rename(old_file_path, new_file_path)
            print(f'Renamed: {filename} -> {new_filename}')
# Replace 'C:\\Users\\xjsd\\Desktop\\outpainting_test_data' with your actual directory path
directory_path = r'C:\Users\xjsd\Desktop\outpainting_test_data'
while 1:
    # Run the rename_files function
    rename_files(directory_path)
    time.sleep(1)
```

【python】chrome浏览器，拖拽图片自动命名文件

# GET方法 StreamingResponse





服务器：

```clike
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from starlette.responses import FileResponse
from pydantic import BaseModel
app = FastAPI()
# 创建一个 Base 模型，用于表示其他的 JSON 信息
class AdditionalInfo(BaseModel):
    message: str
    status: str
@app.get("/get_demo_image_with_json")
async def get_demo_image_with_json():
    # 从文件中读取字节流
    file_path = "face.png"
    file_like = open(file_path, mode="rb")
    # 模拟其他的 JSON 信息
    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")
    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息
    return StreamingResponse(file_like, media_type="image/jpeg",
                             headers={"Additional-Info": json_info.model_dump_json()})
if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

客户端：

```clike
import requests
url = "http://127.0.0.1:8000/get_demo_image_with_json"
response = requests.get(url)
# 检查请求是否成功
if response.status_code == 200:
    # 获取文件的字节流
    image_data = response.content
    # 处理其他的 JSON 信息
    additional_info = response.headers.get("Additional-Info")
    # 在此处添加您的处理逻辑，例如保存字节流到文件，解析 JSON 信息等
    # ...
    print("Image loaded successfully.")
    print(f"Additional Info: {additional_info}")
else:
    print(f"Failed to fetch image. Status code: {response.status_code}")
```

# POST方法 StreamingResponse

服务器代码：

```clike
import io
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
app = FastAPI()
# 创建一个 Base 模型，用于表示其他的 JSON 信息
class AdditionalInfo(BaseModel):
    message: str
    status: str
@app.post("/get_demo_image_with_json")
async def get_demo_image_with_json():
    #  读取face.png
    image_data = open("face.png", "rb").read()
    # 模拟其他的 JSON 信息
    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")
    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息
    return StreamingResponse(io.BytesIO(image_data), media_type="image/png",
                             headers={"Additional-Info": json_info.model_dump_json()})
if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

客户端参数：

```clike
import requests
url = "http://127.0.0.1:8000/get_demo_image_with_json"
response = requests.post(url)
# 检查请求是否成功
if response.status_code == 200:
    # 获取文件的字节流
    image_data = response.content
    # 写入文件
    with open("demo_image_with_json.png", "wb") as fp:
        fp.write(image_data)
    # 打印其他参数
    print(response.headers["Additional-Info"])
else:
    print(f"Failed to fetch image. Status code: {response.status_code}")
```

# 其他

还有FileResponse、base64。

FileResponse太肤浅，base64对于大文件来说太大。


在 FastAPI 中，返回文件字节流的主要方式包括使用 `StreamingResponse` 和 `FileResponse`。这两者都可以用于返回二进制数据，例如图像文件。

1. **StreamingResponse:** 适用于以流式方式发送数据，对于大型文件特别有用，因为它允许在数据生成时就开始发送，而不必等到整个数据集都可用。

    ```python
    from fastapi.responses import StreamingResponse
    @app.get("/get_demo_image")
    async def get_demo_image():
        image_data = open("face.png", "rb").read()
        return StreamingResponse(io.BytesIO(image_data), media_type="image/png")
    ```

2. **FileResponse:** 适用于返回文件，可以从文件系统路径中读取文件内容，也可以通过 `content` 参数直接传递文件内容。

    ```python
    from fastapi.responses import FileResponse
    @app.get("/get_demo_image")
    async def get_demo_image():
        image_data = open("face.png", "rb").read()
        return FileResponse(content=image_data, media_type="image/png")
    ```

这两种方法都是有效的，并且具体的选择可能取决于你的应用程序的需求和性能考虑。如果你希望以异步方式发送文件，你可能会更喜欢 `StreamingResponse`。如果你只是从文件系统中返回文件，`FileResponse` 是一个更简单的选择。

# 上传文件，返回文件的一个示例程序

```clike
from fastapi.responses import StreamingResponse
from fastapi import Depends, FastAPI, Header, Query, Response, UploadFile, Form
# 字节流
@app.post("/image_upscaler_bytes", summary="Image Upscaler Bytes",
          responses={image_upscaler_CustomErrorResponse.error_code:
                         image_upscaler_CustomErrorResponse.to_response_dict()})
def image_upscaler_bytes(image: UploadFile = File(..., title="图像字节流", description="图像字节流"),
                         outscale: float = Form(2, ge=1.0, le=5.0, title="图像超分倍率",
                                                description="图像超分倍率"),
                         requestId: str = Form("", title="Request Id", description="requestId to be returned")):
    """
    Image Upscaler.
    """
    try:
        img = cv2.imdecode(np.fromstring(image.file.read(), np.uint8), cv2.IMREAD_COLOR)
        output, _ = upsampler.enhance(img, outscale=outscale)
        # output = enhance_image(img, outscale=outscale)
        if output is None:
            return image_upscaler_CustomErrorResponse()
        else:
            # 返回字节流
            return StreamingResponse(io.BytesIO(cv2.imencode('.png', output)[1].tobytes()), media_type="image/png",
                                     headers={'requestId': requestId})
    except:
        traceback.print_exc()
        return image_upscaler_CustomErrorResponse(str(traceback.format_exc()))
```

# 关于压缩

```clike
FastAPI本身没有直接支持响应内容压缩的中间件，但你可以通过使用 Starlette 的中间件来实现这一功能。具体来说，Starlette 提供了 `Middleware` 类，你可以使用它来定义自定义中间件。以下是一个简单的例子，演示如何使用 Gzip 中间件来压缩响应内容：
```python

from fastapi import FastAPI

from fastapi.responses import StreamingResponse

from starlette.responses import FileResponse

from starlette.middleware.gzip import GZipMiddleware

from pydantic import BaseModel

app = FastAPI()

# 使用 Gzip 中间件

app.add_middleware(GZipMiddleware, minimum_size=1000, compress_level=6)

# 创建一个 Base 模型，用于表示其他的 JSON 信息

class AdditionalInfo(BaseModel):

    message: str

    status: str

@app.get("/get_demo_image_with_json")

async def get_demo_image_with_json():

    # 从文件中读取字节流

    file_path = "face.png"

    file_like = open(file_path, mode="rb")

    # 模拟其他的 JSON 信息

    json_info = AdditionalInfo(message="Image loaded successfully", status="OK")

    # 使用 StreamingResponse 返回字节流和其他的 JSON 信息

    return StreamingResponse(file_like, media_type="image/jpeg",

                             headers={"Additional-Info": json_info.json()})
```

在上述代码中，通过添加 `GZipMiddleware` 到 FastAPI 应用中，你启用了 Gzip 压缩。在 `StreamingResponse` 中返回的字节流会在传输过程中被压缩。请注意，Gzip 压缩可能会增加 CPU 使用，但通常可以显著减小传输的数据量，提高性能。你可以根据需求调整 `minimum_size` 和 `compress_level` 参数。

FastAPI如何返回文件字节流？并且附带一些json参数

问题：





hon -I/tmp/pip-build-env-eoaar12h/overlay/lib/python3.10/site-packages/numpy/core/include -I/home/xd/stable-diffusion-webui/venv/include -I/usr/include/python3.10 -c insightface/thirdparty/face3d/mesh/cython/mesh_core.cpp -o build/temp.linux-x86_64-cpython-310/insightface/thirdparty/face3d/mesh/cython/mesh_core.o

      x86_64-linux-gnu-gcc -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -Iinsightface/thirdparty/face3d/mesh/cython -I/tmp/pip-build-env-eoaar12h/overlay/lib/python3.10/site-packages/numpy/core/include -I/home/xd/stable-diffusion-webui/venv/include -I/usr/include/python3.10 -c insightface/thirdparty/face3d/mesh/cython/mesh_core_cython.cpp -o build/temp.linux-x86_64-cpython-310/insightface/thirdparty/face3d/mesh/cython/mesh_core_cython.o

      insightface/thirdparty/face3d/mesh/cython/mesh_core_cython.cpp:36:10: fatal error: Python.h: No such file or directory

         36 | #include "Python.h"

            |          ^~~~~~~~~~

      compilation terminated.

      error: command '/usr/bin/x86_64-linux-gnu-gcc' failed with exit code 1

      [end of output]

  note: This error originates from a subprocess, and is likely not a problem with pip.

  ERROR: Failed building wheel for insightface

Failed to build insightface

ERROR: Could not build wheels for insightface, which is required to install pyproject.toml-based projects



It looks like there is a compilation error while trying to build the `insightface` package, and the error is related to the absence of the `Python.h` file. This file is part of the Python development headers and is needed to build Python C extensions.


解决：

To resolve this issue, you need to install the Python development headers. The process to install these headers varies depending on your operating system.


### Ubuntu/Debian Linux:

```bash
sudo apt-get install python3-dev
```

！！！！！！！！！！！！！！！！！！

<mark>我是python3.10，我后面尝试了sudo apt-get install python3.10-dev，非常好用。

### Red Hat/Fedora Linux:

```bash
sudo dnf install python3-devel
```

### macOS:

```bash
xcode-select --install
```

After installing the Python development headers, try installing the `insightface` package again:

```bash
pip install insightface
```

This should resolve the issue you're facing. If you encounter any additional errors or have specific requirements for the `insightface` package, you may need to install additional dependencies as indicated in the package documentation.

安装 insightface Python.h: No such file or directory 36 | #include “Python.h“

根源就是js和ccs文件访问路由的问题，首先你要有本地的文件，详情看[https://qq742971636.blog.csdn.net/article/details/134587010](https://qq742971636.blog.csdn.net/article/details/134587010)。






其次，你需要这么写：

/unicontorlblip就是我配置的mLB网关路由。

```python
app = FastAPI(
    title='outpainting_captioning_upscaler',
    description='outpainting images, captioning images,upscaler images',
    version='1.0.0',
    docs_url=None,
    redoc_url=None,  # 设置 ReDoc 文档的路径
)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
app.mount("/static", StaticFiles(directory="static"), name="static")
@app.get("/docs", include_in_schema=False)
async def custom_swagger_ui_html():
    return get_swagger_ui_html(
        openapi_url="/unicontorlblip/openapi.json",
        title="xx",
        # oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
        swagger_js_url='/unicontorlblip/static/swagger/swagger-ui-bundle.js',
        swagger_css_url='/unicontorlblip/static/swagger/swagger-ui.css',
        swagger_favicon_url='/unicontorlblip/static/swagger/img.png',
    )
```

![在这里插入图片描述](/static/img/images/03780.png)

Python，FastAPI，mLB网关，无法访问/docs

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。