【AI】CycleGan对抗生成网络遥感影像生成地图效果测试

news2024/11/15 16:02:03

今天看到一个有趣的项目，CycleGan对抗生成网络把马生成成斑马，还有一个测试用例是用遥感影像生成平面地图的效果，效果如下图所示，我大学是遥感专业，看到遥感影像就触动了我的原神，于是原神启动，肝一个测试的玩玩。
在这里插入图片描述

源码地址：https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix

0.准备工作

其实按照官方文档玩，没有什么特别需要准备的，只是为了防止遗忘，多赘述一下了。
项目有提供数据集和预训练模型，这种最适合懒人操作了。

  1. 下载数据集
    其实源码中已经放了下载数据集的脚本，只需要运行脚本即可，但是有时候下载不稳定，我们还是提前下载下来放在环境下面最稳妥。
    下载地址：http://efrosgans.eecs.berkeley.edu/cyclegan/datasets
    在这里插入图片描述
    解压后放在项目的dataset目录下面
    在这里插入图片描述

  2. 下载预训练模型
    下载地址：http://efrosgans.eecs.berkeley.edu/cyclegan/pretrained_models/
    在这里插入图片描述
    预训练模型下载之后需要改一下名字，在项目的checkpoint目录下面创建预训练模型的文件夹，并把下载的预训练模型改名为latest_net_G.pth
    在这里插入图片描述
    3.安装依赖
    我这边使用的Anaconda虚拟环境进行运行，选择一个之前安装了pytorch框架的虚拟环境，然后再终端中切换到项目文件夹下面，使用pip install -r requirments.txt安装项目依赖。
    项目依赖挺简单，除了pytorch的包外，最主要的就是两个包了，因为我的虚拟环境上已经安装了pytorch的依赖，所以前两个依赖可以注释掉

#torch>=0.4.1
#torchvision>=0.2.1
dominate>=2.3.1
visdom>=0.1.8.3

1.运行测试

安装完就可以运行了，直接在项目的根目录下面运行即可

python test.py --dataroot datasets/maps/testA --name sat2map_pretrained --model test --no_dropout

参数介绍：

--dataroot 测试数据集存放的路径
--name 模型名称，这里跟checkpoint目录下面的文件夹名称一致
--model test 使用test参数说明我们是在测试

终端输出内容展示：

(pytorch) PS F:\AIStudy\pytorch-CycleGAN-and-pix2pix> python test.py --dataroot datasets/maps/testA --name sat2map_pretrained --model test --no_dropout
----------------- Options ---------------
             aspect_ratio: 1.0
               batch_size: 1
          checkpoints_dir: ./checkpoints
                crop_size: 256
                 dataroot: datasets/maps/testA                  [default: None]
             dataset_mode: single
                direction: AtoB
          display_winsize: 256
                    epoch: latest
                     eval: False
                  gpu_ids: 0
                init_gain: 0.02
                init_type: normal
                 input_nc: 3
                  isTrain: False                                [default: None]
                load_iter: 0                                    [default: 0]
                load_size: 256
         max_dataset_size: inf
                    model: test
             model_suffix:
               n_layers_D: 3
                     name: sat2map_pretrained                   [default: experiment_name]
                      ndf: 64
                     netD: basic
                     netG: resnet_9blocks
                      ngf: 64
               no_dropout: True                                 [default: False]
                  no_flip: False
                     norm: instance
                    ntest: inf
                 num_test: 50
              num_threads: 4
                output_nc: 3
                    phase: test
               preprocess: resize_and_crop
              results_dir: ./results/
           serial_batches: False
                   suffix:
                  verbose: False
----------------- End -------------------
dataset [SingleDataset] was created
[ReflectionPad2d((3, 3, 3, 3)), Conv2d(3, 64, kernel_size=(7, 7), stride=(1, 1)), InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)), InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)), InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
)]
[ReflectionPad2d((3, 3, 3, 3)), Conv2d(3, 64, kernel_size=(7, 7), stride=(1, 1)), InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)), InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)), InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ResnetBlock(
  (conv_block): Sequential(
    (0): ReflectionPad2d((1, 1, 1, 1))
    (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (2): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
    (3): ReLU(inplace=True)
    (4): ReflectionPad2d((1, 1, 1, 1))
    (5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (6): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
  )
), ConvTranspose2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1)), InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1)), InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False), ReLU(inplace=True), ReflectionPad2d((3, 3, 3, 3)), Conv2d(64, 3, kernel_size=(7, 7), stride=(1, 1)), Tanh()]
initialize network with normal
model [TestModel] was created
loading the model from ./checkpoints\sat2map_pretrained\latest_net_G.pth
---------- Networks initialized -------------
[Network G] Total number of parameters : 11.378 M
-----------------------------------------------
creating web directory ./results/sat2map_pretrained\test_latest
processing (0000)-th image... ['datasets/maps/testA\\1000_A.jpg']
processing (0005)-th image... ['datasets/maps/testA\\1005_A.jpg']
processing (0010)-th image... ['datasets/maps/testA\\100_A.jpg']
processing (0015)-th image... ['datasets/maps/testA\\1014_A.jpg']
processing (0020)-th image... ['datasets/maps/testA\\1019_A.jpg']
processing (0025)-th image... ['datasets/maps/testA\\1023_A.jpg']
processing (0030)-th image... ['datasets/maps/testA\\1028_A.jpg']
processing (0035)-th image... ['datasets/maps/testA\\1032_A.jpg']
processing (0040)-th image... ['datasets/maps/testA\\1037_A.jpg']
processing (0045)-th image... ['datasets/maps/testA\\1041_A.jpg']

这里打印了模型参数、模型结构以及处理进度。

2.结果展示

执行结束后会在模型的result路径下（results\sat2map_pretrained\test_latest）生成查看样例，点击打开index.html就可以查看模型处理的效果
在这里插入图片描述
效果如下：
在这里插入图片描述
是不是很有趣！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1372697.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

@Transactional 事务注解

@Transactional 事务注解

第一、先简单介绍一下Spring事务的传播行为 所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量&…
阅读更多...
C++学习笔记——返回对象

C++学习笔记——返回对象

一、返回对象 当我们说一个函数返回对象时，意味着该函数的返回值是一个对象。这种情况下，函数可以通过创建对象的副本、返回对象的引用或者返回对象的指针来实现。 返回对象的副本： 当一个函数返回对象的副本时，函数内部会创建一…
阅读更多...
VSCode使用MinGW编译器，配置C/C++环境

VSCode使用MinGW编译器，配置C/C++环境

目录 一、安装VSCode 二、安装MinGW编译器 1、配置环境变量 2、测试配置是否成功 三、配置VSCode 1、安装所需扩展 2、新建代码存放文件夹 3、添加配置文件 4、配置文件内容 （1）c_cpp_properties.json （2）launch.json …
阅读更多...
11 个 Python全栈开发工具集

11 个 Python全栈开发工具集

前言 以下是专注于全栈开发不同方面的 Python 库;有些专注于 Web 应用程序开发，有些专注于后端，而另一些则两者兼而有之。 1. Taipy Taipy 是一个开源的 Python 库，用于构建生产就绪的应用程序前端和后端。 它旨在加快应用程序开发&#xf…
阅读更多...
数字战场上的坚固屏障：雷池社区版（WAF）

数字战场上的坚固屏障：雷池社区版（WAF）

黑客的挑战 智能语义分析算法： 黑客们常利用复杂技术进行攻击，但雷池社区版的智能语义分析算法能深入解析攻击本质，即使是最复杂的攻击手法也难以逃脱。 0day攻击防御： 传统防火墙难以防御未知攻击，但雷池社区版能有效…
阅读更多...
云卷云舒：kubernetes简介

云卷云舒：kubernetes简介

Kubernetes是由google公司在2014年发布的一款开源的容器编排引擎，用于容器化应用程序的自动化部署、扩展与管理。它能够编排多种容器任务，涵盖虚拟机集群管理、负载均衡以及网络流量分配等等。2017年，aws、微软云、阿里云等等著名的云计算公司…
阅读更多...
用Linux的视角来理解缓冲区概念

用Linux的视角来理解缓冲区概念

缓冲区的认识 缓冲区（buffer）是存储数据的临时存储区域。当我们用C语言向文件中写入数据时，数据并不会直接的写到文件中，中途还经过了缓冲区，而我们需要对缓冲区的数据进行刷新，那么数据才算写到文件当中。…
阅读更多...
Js-基础语法（二）

Js-基础语法（二）

运算符 赋值运算符 赋值运算符：对变量进行赋值的运算符 已经学过的赋值运算符： 将等号右边的值赋予给左边, 要求左边必须是一个容器 其他赋值运算符： - */% 使用这些运算符可以在对变量赋值时进行快速操作 一元运算符 众多的 JavaScrip…
阅读更多...
10个提高 Python Web 开发效率的VS Code插件

10个提高 Python Web 开发效率的VS Code插件

VS Code具有灵活、便捷和丰富的可用插件库，是Web开发人员中非常受欢迎的代码编辑器。 本文介绍10个VS Code插件，它们可以提高你作为Web开发人员的工作效率。 1. Live Preview Live Preview插件支持在VS Code的小型浏览器中查看网站。因此，无…
阅读更多...
40-特殊运算符delete,new,.getDate,.setDate,运算符优先级

40-特殊运算符delete,new,.getDate,.setDate,运算符优先级

1.delete删除. 数组 // 可以删除数组元素，可以删除对象键值对// 删除数组的值，数组长度保持不变// 删掉的值变成emptyvar arr [1,2,3,4,5];delete arr[0];console.log(arr); 对象 var obj {"a":"aa","b":"bb&quo…
阅读更多...
LeNet-5(fashion-mnist)

LeNet-5(fashion-mnist)

文章目录 前言LeNet模型训练 前言 LeNet是最早发布的卷积神经网络之一。该模型被提出用于识别图像中的手写数字。 LeNet LeNet-5由以下两个部分组成 卷积编码器（2）全连接层（3） 卷积块由一个卷积层、一个sigmoid激活函数和一个…
阅读更多...
数据结构及单链表例题(下)

数据结构及单链表例题(下)

上次我们已经了解了单链表的数据结构定义以及创建单链表的两种方法,这节介绍几道例题. 文章目录 前言 一、已知L为带头结点的单链表,请依照递归思想实现下列运算 二、单链表访问第i个数据节点 三、在第i个元素前插入元素e 四、删除第i个结点 五、查找带头结点单链表倒数第…
阅读更多...
Vivado开发FPGA使用流程、教程 verilog（建立工程、编译文件到最终烧录的全流程）

Vivado开发FPGA使用流程、教程 verilog（建立工程、编译文件到最终烧录的全流程）

目录 一、概述 二、工程创建 三、添加设计文件并编译 四、线上仿真 五、布局布线 六、生成比特流文件 七、烧录 一、概述 vivado开发FPGA流程分为创建工程、添加设计文件、编译、线上仿真、布局布线（添加约束文件）、生成比特流文件、烧录等步骤&a…
阅读更多...
公司内部核心文件数据\资料防泄密软件系统，防止未经授权文件、文档、图纸、源代码、音视频...等数据资料外泄，自动智能透明加密保护！

公司内部核心文件数据\资料防泄密软件系统，防止未经授权文件、文档、图纸、源代码、音视频...等数据资料外泄，自动智能透明加密保护！

为了保护公司内部的核心文件和数据资料，防止未经授权的外泄，使用自动智能透明加密保护软件系统是非常重要的。 这样的系统可以通过以下方式实现防泄密： 自动智能加密：该系统可以对公司内部的核心文件和数据资料进行自动智能加密&…
阅读更多...
夏目友人帐OVA：和猫咪老师的初次跑腿、曾几何时下雪之日 2013.12.15

夏目友人帐OVA：和猫咪老师的初次跑腿、曾几何时下雪之日 2013.12.15

夏目友人帐OVA 1、和猫咪老师的初次跑腿 / ニャンコ先生とはじめてのおつかい2、曾几何时下雪之日 / いつかゆきのひに 1、和猫咪老师的初次跑腿 / ニャンコ先生とはじめてのおつかい 和夏目一起外出的途中，猫咪老师因追蜻蜓遇到了一对迷路的龙凤胎兄妹。猫咪老师不…
阅读更多...
僵尸毁灭工程手动存档工具

僵尸毁灭工程手动存档工具

介绍 这是一个可以对僵毁游戏存档进行备份的小工具，其基本原理是对僵毁存档中数以万计的小文件做哈希值计算并保存下来，下一次备份时再对存档文件进行哈希值计算，每次备份只对两次计算结果中存在差异的文件进行复制与替换从而忽略掉大部分未…
阅读更多...
汽车IVI中控开发入门及进阶（十二）：手机投屏

汽车IVI中控开发入门及进阶（十二）：手机投屏

前言： 汽车座舱有车载中控大屏、仪表/HUD多屏的显示能力，有麦克风/喇叭等车载环境更好的音频输入输出能力，有方控按键、旋钮等方便的反向控制输入能力，还有高精度的车辆数据等。但汽车座舱中控主机硬件计算能力升级迭代周期相对较长，汽车的应用和服务不够丰富。现在很多汽…
阅读更多...
电脑USB接口不同颜色的含义

电脑USB接口不同颜色的含义

当你看到笔记本电脑或台式机的USB端口时，你会发现USB端口的颜色很多；这些颜色可不只是为了好看，实际上不同颜色代表着不同的性能，那么这些带颜色的USB端口都是什么含义呢，下面就具体介绍下不同颜色代表的含义。-----吴…
阅读更多...
Oracle regexp_substr

Oracle regexp_substr

select regexp_substr(123|456|789, [^|], 1, 2) from dual;
阅读更多...
高性能、可扩展、支持二次开发的企业电子招标采购系统源码

高性能、可扩展、支持二次开发的企业电子招标采购系统源码

在数字化时代，企业需要借助先进的数字化技术来提高工程管理效率和质量。招投标管理系统作为企业内部业务项目管理的重要应用平台，涵盖了门户管理、立项管理、采购项目管理、采购公告管理、考核管理、报表管理、评审管理、企业管理、采购管理和系统管理等…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023