19、图算法与图像处理技术详解

于 2025-08-28 13:42:49 发布
阅读量33 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Go语言实战精华 文章标签： 图算法 Dijkstra算法 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/data3/article/details/151205630

图算法与图像处理技术详解

1. 图节点的移除操作

在图结构中，移除节点是一项常见操作。以下是移除节点的代码实现： 

func (g *Graph) RemoveNode(name string) {
    r := -1
    for i, n := range g.Nodes {
        if n.name == name {
            r = i
        }
    }
    if r > -1 {
        g.Nodes[r] = g.Nodes[len(g.Nodes)-1] // remove the node
        g.Nodes = g.Nodes[:len(g.Nodes)-1]
    }
    delete(g.Edges, name) // remove the edge from one side
    // remove the edge from the other side
    for n := range g.Edges {
        removeEdge(g, n, name)
    }
}

操作步骤如下：
1. 遍历图的节点列表，找到要移除的节点的索引 r 。
2. 如果找到该节点，将其与节点列表的最后一个节点交换位置，并从节点列表中移除该节点。
3. 从边的映射中删除与该节点相关的边。
4. 遍历边的映射，移除所有与该节点相关的边。

2. 图的最短路径算法 - Dijkstra算法

Dijkstra算法是一种用于在加权图中找到两个节点之间最短路径的经典算法。

2.1 算法背景

图是一种常用的数据结构，在社交媒体、地图应用等领域有广泛应用。Dijkstra算法由计算机科学巨人Edsger Dijkstra于1959年提出，用于解决图中任意两个给定节点之间的最短路径问题。

2.2 算法所需数据结构
  • 加权图
  • 最小堆

节点结构体定义如下： 

type Node struct {
    name    string
    value   int
    through *Node
}
2.3 构建图 
func buildGraph() *Graph {
    graph := NewGraph()
    nodes := make(map[string]*Node)
    names := []string{"London", "Paris", "Amsterdam", "Luxembourg",
        "Zurich", "Rome", "Berlin", "Vienna", "Warsaw", "Istanbul"}
    for _, name := range names {
        n := &Node{name, math.MaxInt, nil}
        graph.AddNode(n)
        nodes[name] = n
    }
    graph.AddEdge(nodes["London"], nodes["Paris"], 80)
    graph.AddEdge(nodes["London"], nodes["Luxembourg"], 75)
    graph.AddEdge(nodes["London"], nodes["Amsterdam"], 75)
    graph.AddEdge(nodes["Paris"], nodes["Luxembourg"], 60)
    graph.AddEdge(nodes["Paris"], nodes["Rome"], 125)
    graph.AddEdge(nodes["Luxembourg"], nodes["Berlin"], 90)
    graph.AddEdge(nodes["Luxembourg"], nodes["Zurich"], 60)
    graph.AddEdge(nodes["Luxembourg"], nodes["Amsterdam"], 55)
    graph.AddEdge(nodes["Zurich"], nodes["Vienna"], 80)
    graph.AddEdge(nodes["Zurich"], nodes["Rome"], 90)
    graph.AddEdge(nodes["Zurich"], nodes["Berlin"], 85)
    graph.AddEdge(nodes["Berlin"], nodes["Amsterdam"], 85)
    graph.AddEdge(nodes["Berlin"], nodes["Vienna"], 75)
    graph.AddEdge(nodes["Vienna"], nodes["Rome"], 100)
    graph.AddEdge(nodes["Vienna"], nodes["Istanbul"], 130)
    graph.AddEdge(nodes["Warsaw"], nodes["Berlin"], 80)
    graph.AddEdge(nodes["Warsaw"], nodes["Istanbul"], 180)
    graph.AddEdge(nodes["Rome"], nodes["Istanbul"], 155)
    return graph
}
2.4 Dijkstra算法实现 
func dijkstra(graph *Graph, city string) {
    visited := make(map[string]bool)
    heap := &Heap{}
    startNode := graph.GetNode(city)
    startNode.value = 0
    heap.Push(startNode)
    for heap.Size() > 0 {
        current := heap.Pop()
        visited[current.name] = true
        edges := graph.Edges[current.name]
        for _, edge := range edges {
            if !visited[edge.node.name] {
                heap.Push(edge.node)
                if current.value+edge.weight < edge.node.value {
                    edge.node.value = current.value +
                        edge.weight
                    edge.node.through = current
                }
            }
        }
    }
}
2.5 算法操作步骤
  1. 设置加权图、最小堆和一个用于标记已访问节点的映射。
  2. 获取起始节点，将其值设为0，并将其压入堆中。
  3. 进入循环，当堆不为空时，弹出堆顶元素作为当前节点。
  4. 标记当前节点为已访问。
  5. 对于当前节点连接的每个未访问节点，将其压入堆中。
  6. 检查当前节点的值加上边的权重是否小于连接节点的值。
  7. 如果是，则更新连接节点的值和 through 字段。
  8. 重复步骤3 - 7，直到所有节点都被访问。

以下是算法调用示例： 

func main() {
    // build and run Dijkstra's algorithm on graph
    graph := buildGraph()
    city := os.Args[1]
    dijkstra(graph, city)
    // display the nodes
    for _, node := range graph.Nodes {
        fmt.Printf("Shortest time from %s to %s is %d\n",
            city, node.name, node.value)
        for n := node; n.through != nil; n = n.through {
            fmt.Print(n, " <- ")
        }
        fmt.Println(city)
        fmt.Println()
    }
}
3. 图像处理基础

在图像处理中，Go语言的 image 包是处理2D图像的标准库，主要接口是 image.Image 。

3.1 常用接口和结构体
类型 描述
image.Image 表示一个矩形像素网格，实现该接口的结构体需实现 ColorModel 、 Bounds 和 At 方法
color.Color 表示一种颜色，有 RGBA 方法返回红、绿、蓝和透明度值
image.Rectangle 由左上角和右下角点定义的矩形
image.Point 由X和Y值定义的位置
3.2 图像实现结构体

以 NRGBA 为例，它是 image.Image 的一种实现： 

type NRGBA struct {
    Pix    []uint8
    Stride int
    Rect   Rectangle
}

其中， Pix 是包含图像像素的字节切片， Stride 是垂直相邻像素之间的距离， Rect 是图像的尺寸。

4. 图像加载操作

要从文件中加载图像，可以使用以下代码： 

func load(filePath string) *image.NRGBA {
    imgFile, err := os.Open(filePath)
    if err != nil {
        log.Println("Cannot read file:", err)
    }
    defer imgFile.Close()
    img, _, err := image.Decode(imgFile)
    if err != nil {
        log.Println("Cannot decode file:", err)
    }
    rimg, ok := img.(*image.NRGBA)
    if ok {
        return rimg, nil
    }
    return nil, errors.New("cannot type assert image")
}

操作步骤如下：
1. 打开图像文件。
2. 使用 image.Decode 解码文件内容。
3. 将解码后的 Image 类型断言为 NRGBA 类型，因为 NRGBA 是可操作的具体实现。

5. 图像保存操作

要将图像保存到文件，可以使用以下代码： 

import "image/png"

func save(filePath string, img *image.NRGBA) {
    imgFile, err := os.Create(filePath)
    defer imgFile.Close()
    if err != nil {
        log.Println("Cannot create file:", err)
    }
    png.Encode(imgFile, img.SubImage(img.Rect))
}

操作步骤如下：
1. 创建文件。
2. 使用 png.Encode （或其他格式的 Encode 方法）将图像编码到文件中。
3. 由于 Encode 方法接受 Image 接口作为参数，需要使用 SubImage 方法将 NRGBA 转换为 Image 类型。

6. 图像创建操作

要创建一个新图像，可以使用以下代码： 

func main() {
    rect := image.Rect(0, 0, 100, 100)
    img := createRandomImage(rect)
    save("random.png", img)
}

func createRandomImage(rect image.Rectangle) (created *image.NRGBA) {
    pix := make([]uint8, rect.Dx()*rect.Dy()*4)
    rand.Read(pix)
    created = &image.NRGBA{
        Pix:    pix,
        Stride: rect.Dx() * 4,
        Rect:   rect,
    }
    return
}

操作步骤如下：
1. 创建一个 Rectangle 表示图像的尺寸。
2. 创建一个字节切片 Pix ，其大小为图像像素数量乘以4（每个像素由4个字节表示）。
3. 使用 rand.Read 填充 Pix 切片，生成随机像素值。
4. 创建 NRGBA 结构体实例，设置 Pix 、 Stride 和 Rect 字段。
5. 保存图像到文件。

7. 图像翻转操作

要将图像上下翻转，可以使用以下代码： 

func load(filePath string) (grid [][]color.Color) {
    // open the file and decode the contents into an image
    file, err := os.Open(filePath)
    if err != nil {
        log.Println("Cannot read file:", err)
    }
    defer file.Close()
    img, _, err := image.Decode(file)
    if err != nil {
        log.Println("Cannot decode file:", err)
    }
    // create and return a grid of pixels
    size := img.Bounds().Size()
    for i := 0; i < size.X; i++ {
        var y []color.Color
        for j := 0; j < size.Y; j++ {
            y = append(y, img.At(i, j))
        }
        grid = append(grid, y)
    }
    return
}

func save(filePath string, grid [][]color.Color) {
    // create an image and set the pixels using the grid
    xlen, ylen := len(grid), len(grid[0])
    rect := image.Rect(0, 0, xlen, ylen)
    img := image.NewNRGBA(rect)
    for x := 0; x < xlen; x++ {
        for y := 0; y < ylen; y++ {
            img.Set(x, y, grid[x][y])
        }
    }
    // create a file and encode the image into it
    file, err := os.Create(filePath)
    if err != nil {
        log.Println("Cannot create file:", err)
    }
    defer file.Close()
    png.Encode(file, img.SubImage(img.Rect))
}

func flip(grid [][]color.Color) {
    for x := 0; x < len(grid); x++ {
        col := grid[x]
        for y := 0; y < len(col)/2; y++ {
            z := len(col) - y - 1
            col[y], col[z] = col[z], col[y]
        }
    }
}

func main() {
    grid := load("monalisa.png")
    flip(grid)
    save("flipped.png", grid)
}

操作步骤如下：
1. 扩展 load 函数，将图像转换为像素网格。
2. 扩展 save 函数，将像素网格转换回图像并保存到文件。
3. 实现 flip 函数，遍历网格的每一列，交换顶部和底部的像素对。
4. 调用 load 函数加载图像，调用 flip 函数翻转图像，最后调用 save 函数保存翻转后的图像。

通过以上步骤，我们可以完成图节点的移除、图的最短路径计算以及图像的加载、保存、创建和翻转等操作。这些技术在实际应用中具有广泛的用途，如社交网络分析、地图导航和图像处理等领域。

图算法与图像处理技术详解

8. 图算法与图像处理操作流程总结

为了更清晰地展示上述操作的流程，下面通过表格和流程图进行总结。

8.1 操作流程表格
操作类型 主要步骤
图节点移除 1. 遍历节点列表找到要移除节点的索引；2. 交换节点位置并移除；3. 删除相关边；4. 移除所有与该节点相关的边
图最短路径计算（Dijkstra算法） 1. 设置加权图、最小堆和访问标记映射；2. 初始化起始节点并压入堆；3. 循环处理堆中的节点；4. 更新连接节点的值和 through 字段
图像加载 1. 打开图像文件；2. 解码文件内容；3. 类型断言为 NRGBA 类型
图像保存 1. 创建文件；2. 将 NRGBA 转换为 Image 类型；3. 编码图像到文件
图像创建 1. 创建图像尺寸的 Rectangle ；2. 创建并填充 Pix 切片；3. 创建 NRGBA 实例；4. 保存图像
图像翻转 1. 将图像转换为像素网格；2. 交换网格中顶部和底部的像素对；3. 将网格转换回图像并保存
8.2 图最短路径计算（Dijkstra算法）流程图 
graph TD
    A[初始化加权图、最小堆和访问标记映射] --> B[获取起始节点，设值为0并压入堆]
    B --> C{堆是否为空}
    C -- 否 --> D[弹出堆顶元素作为当前节点]
    D --> E[标记当前节点为已访问]
    E --> F[获取当前节点的连接边]
    F --> G[遍历连接边]
    G -- 未访问 --> H[将连接节点压入堆]
    H --> I{当前节点值+边权重 < 连接节点值}
    I -- 是 --> J[更新连接节点值和 through 字段]
    J --> C
    G -- 已访问 --> C
    C -- 是 --> K[结束算法]
9. 代码示例总结与分析

以下是对上述代码示例的总结和分析，帮助大家更好地理解和应用这些代码。

9.1 图算法代码
  • 节点移除代码 ：通过遍历节点列表找到要移除的节点，然后交换位置并删除相关边，确保图结构的正确性。 
func (g *Graph) RemoveNode(name string) {
    r := -1
    for i, n := range g.Nodes {
        if n.name == name {
            r = i
        }
    }
    if r > -1 {
        g.Nodes[r] = g.Nodes[len(g.Nodes)-1] // remove the node
        g.Nodes = g.Nodes[:len(g.Nodes)-1]
    }
    delete(g.Edges, name) // remove the edge from one side
    // remove the edge from the other side
    for n := range g.Edges {
        removeEdge(g, n, name)
    }
}
  • Dijkstra算法代码 ：利用最小堆和访问标记映射，不断更新节点的值和 through 字段，最终找到最短路径。 
func dijkstra(graph *Graph, city string) {
    visited := make(map[string]bool)
    heap := &Heap{}
    startNode := graph.GetNode(city)
    startNode.value = 0
    heap.Push(startNode)
    for heap.Size() > 0 {
        current := heap.Pop()
        visited[current.name] = true
        edges := graph.Edges[current.name]
        for _, edge := range edges {
            if !visited[edge.node.name] {
                heap.Push(edge.node)
                if current.value+edge.weight < edge.node.value {
                    edge.node.value = current.value +
                        edge.weight
                    edge.node.through = current
                }
            }
        }
    }
}
9.2 图像处理代码
  • 图像加载代码 ：打开文件并解码内容，将其转换为可操作的 NRGBA 类型。 
func load(filePath string) *image.NRGBA {
    imgFile, err := os.Open(filePath)
    if err != nil {
        log.Println("Cannot read file:", err)
    }
    defer imgFile.Close()
    img, _, err := image.Decode(imgFile)
    if err != nil {
        log.Println("Cannot decode file:", err)
    }
    rimg, ok := img.(*image.NRGBA)
    if ok {
        return rimg, nil
    }
    return nil, errors.New("cannot type assert image")
}
  • 图像保存代码 ：创建文件并将 NRGBA 转换为 Image 类型，然后编码保存。 
import "image/png"

func save(filePath string, img *image.NRGBA) {
    imgFile, err := os.Create(filePath)
    defer imgFile.Close()
    if err != nil {
        log.Println("Cannot create file:", err)
    }
    png.Encode(imgFile, img.SubImage(img.Rect))
}
  • 图像创建代码 ：通过创建 Rectangle 和填充 Pix 切片，创建并保存随机图像。 
func main() {
    rect := image.Rect(0, 0, 100, 100)
    img := createRandomImage(rect)
    save("random.png", img)
}

func createRandomImage(rect image.Rectangle) (created *image.NRGBA) {
    pix := make([]uint8, rect.Dx()*rect.Dy()*4)
    rand.Read(pix)
    created = &image.NRGBA{
        Pix:    pix,
        Stride: rect.Dx() * 4,
        Rect:   rect,
    }
    return
}
  • 图像翻转代码 ：将图像转换为像素网格，交换像素对，再转换回图像保存。 
func load(filePath string) (grid [][]color.Color) {
    // open the file and decode the contents into an image
    file, err := os.Open(filePath)
    if err != nil {
        log.Println("Cannot read file:", err)
    }
    defer file.Close()
    img, _, err := image.Decode(file)
    if err != nil {
        log.Println("Cannot decode file:", err)
    }
    // create and return a grid of pixels
    size := img.Bounds().Size()
    for i := 0; i < size.X; i++ {
        var y []color.Color
        for j := 0; j < size.Y; j++ {
            y = append(y, img.At(i, j))
        }
        grid = append(grid, y)
    }
    return
}

func save(filePath string, grid [][]color.Color) {
    // create an image and set the pixels using the grid
    xlen, ylen := len(grid), len(grid[0])
    rect := image.Rect(0, 0, xlen, ylen)
    img := image.NewNRGBA(rect)
    for x := 0; x < xlen; x++ {
        for y := 0; y < ylen; y++ {
            img.Set(x, y, grid[x][y])
        }
    }
    // create a file and encode the image into it
    file, err := os.Create(filePath)
    if err != nil {
        log.Println("Cannot create file:", err)
    }
    defer file.Close()
    png.Encode(file, img.SubImage(img.Rect))
}

func flip(grid [][]color.Color) {
    for x := 0; x < len(grid); x++ {
        col := grid[x]
        for y := 0; y < len(col)/2; y++ {
            z := len(col) - y - 1
            col[y], col[z] = col[z], col[y]
        }
    }
}

func main() {
    grid := load("monalisa.png")
    flip(grid)
    save("flipped.png", grid)
}
9. 实际应用场景

上述图算法和图像处理技术在实际应用中有着广泛的用途，以下是一些常见的应用场景：
- 社交网络分析 ：图算法可用于分析社交网络中用户之间的关系，例如找到两个用户之间的最短连接路径，帮助推荐好友等。
- 地图导航 ：Dijkstra算法可以用于计算地图中两个地点之间的最短路径，为用户提供最优的导航路线。
- 图像处理 ：图像的加载、保存、创建和翻转等操作在图像编辑、计算机视觉等领域有着重要的应用，例如图像的预处理、特效制作等。

通过掌握这些图算法和图像处理技术，我们可以更好地解决实际问题，提高开发效率和应用的性能。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值