算法 & 数据结构——收纳箱算法???

.  最近工作上有一个需求,需要将图片打包成图集,以便于让资源更紧凑,利用率更高,提升性能,游戏行内的同志应该很熟练这个操作.通常我们需要用一个app来完成这项工作,最出名的莫过于Texture Packer

Texture Packer官方示意图
Texture Packer官方示意图

.  最早接触到这一概念的时候,我还是一个学生,当时玩的《暗黑魔破坏神2》,它有一个背包系统,这个背包系统跟现在大多数游戏都不一样,它的道具存放并非等大小,比如长剑比匕首长,斧头比长剑宽,因此在摆放道具时,不能乱放,不然背包就不够用。

暗黑破坏神2背包截图
暗黑破坏神2背包截图

.  这是一个很有意思的设计,但现在基本上绝迹了,以至于我想到游戏中的背包就会不禁想起暗黑破坏神2的背包系统,我在《天龙八部》游戏中,第一次发现了背包自动整理这一项功能,但是它的背包道具都是等大小的,所以平平无奇,但却不由让我想到《暗黑破坏神2》的背包自动整理,它必然会涉及到一个最优排列组合算法。这个疑惑一直困扰了我很多年,它到底是怎么实现的?直到上周,我重新打开了《暗黑破坏神2》这款游戏,发现它根本没有这个功能,童年幻想破灭~

.  虽然童年幻想破灭了,但成年梦想得跟上,正好工作有这么一个让我去实现的机会,于是我尝试去思考算法,起初想到经典的《背包算法》,仔细研究后发现不太适用,于是放弃。不得不说,厕所是一个很适合思考的地方,因为后来的实现方案是我在蹲厕所的时候突然就想出来了。有没有科学上的解释?

收纳箱算法?

.  这个算法跟我们日常使用收纳箱的思路很相似,起初收纳箱是空的,它只有一个存放空间,但是很大.之后我们逐个物品往里面放,每次放进去一个物品,原来的空间都会被拆分成两个,最后空间越来越小,直到不能装下剩下的物品,或者物品放完了,这一过程就结束了.

收纳箱示意图
收纳箱示意图

.  上图清晰描述了收纳箱的存放过程,绿色是收纳箱,黄色是物品,起初收纳箱是空的,只有一个空间,放进物品后,空间被拆分了,这一步是关键,因为放进一个物品会有两种拆分策略,红色线和棕色线分表分表显示了两种拆分策略,如果按红色线拆分,则会产生一个很小的空间和一个很大的空间,如果按棕色线拆分,则产生两个大小均匀的空间。这两种策略对应不同的物品有奇效。每次放进去一个物品,收纳箱的一处空间就会被占用,而算法只考虑没有被占用的空间即可。

.  接下来就是逐个物品往收纳箱里放,这一步也是关键,因为每次放进一个物品,空间都会被划分,这个划分依据是物品的大小,如果先放进去一个很小的物品,比如1x1大小的物品,那么空间无论怎么分,都会产生一个很狭窄的空间,这个狭窄的空间很可能存不下后续的任何物品,那么这个空间就浪费了,因此在此之前,先对所有物品进行一个排序,这个排序可以按物品的面积,物品的宽度,物品的高度,物品的最长的边,等等。这些排列策略也会影响最终的排列组合。

改进

空间被浪费
空间被浪费

.  上图是一个空间被浪费的例子,因为上文描述的算法需要已知收纳箱大小,比如已知收纳箱512x512大小,如果物品总面积超出这个大小,则装不下,如果物品远小于这个大小,则浪费空间,所以算法能动态计算大小,那就再好不过了。不过谢天谢地,很容易就可以搞定这个问题,我们只需要提前计算出单个物品最大需要的大小,用这个大小作为收纳箱的大小就可以了。

自动适应
自动适应

.  优化过后,已经提高了不少空间利用率,第一个收纳箱装进了最大的物品,后面的收纳箱采用较小的尺寸继续装剩下的物品,直到全部装完为止。但是这里产生了一个新问题,会生成多个收纳箱,如果多个收纳箱都很小,那资源复用率就下降了,所以还需要进一步优化,尽可能提高资源复用率。比如两个128x128可以合并成一个256x256,两个256x256可以合并成一个512x512。

.  思路是这样的,设定一个打包级别,当这个级别的打包数量达到一个值,就将这个级别提升一级,再重新打包,直到所有级别的收纳箱都没有超出限制。比如,128x128 2,256x256 2,512x512 3 分别代表三个不同的级别,他们是递增关系,当128x128的收纳箱达到2个的时候,说明它需要提升一个级别重新打包,于是级别提升到256x256,依次类推。

最终版本
最终版本

以上结果是采用按棕色线拆分空间,按物品最长边排序,及以下打包级别:

{ 128, 128, 1 },
{ 256, 256, 2 },
{ 512, 512, 3 },
{ 1024, 1024, 4 },
{ 2048, 2048, 100 },

动态图
动态图

//  storage_box.h
#pragma once

#include <list>
#include <tuple>
#include <array>
#include <vector>
#include <cassert>
#include <algorithm>

using iint = int;
using uint = unsigned int;

class StorageBox {
public:
    struct Item {
        uint i;
        uint w;
        uint h;

        uint GetV() const
        {
            return std::max(w, h);
        }
    };

    struct ResultItem {
        uint i;
        uint x;
        uint y;
        uint w;
        uint h;

        ResultItem(): i((uint)~0)
        { }

        uint GetV() const
        {
            return w * h;
        }

        bool IsReady() const
        {
            return i != (uint)~0;
        }
      
        bool IsContains(const Item & item) const
        {
            return w >= item.w && h >= item.h;
        }

        bool AddItem(const Item & item, ResultItem * out0, ResultItem * out1)
        {
            if (!IsContains(item))
            {
                return false;
            }
            auto nx = x + item.w;
            auto ny = y + item.h;
            auto s0 = (w - item.w) * item.h;
            auto s1 = (h - item.h) * w;
            auto s2 = (w - item.w) * h;
            auto s3 = (h - item.h) * item.w;
            //  两种切分策略:
            //      按最大面积切分
            //      按均匀面积切分
            //if (std::max(s0, s1) > std::max(s2, s3))
            if (std::max(s0, s1) - std::min(s0, s1) < std::max(s2, s3) - std::min(s2, s3))
            {
                out0->x = nx;
                out0->y = y;
                out0->w = w - item.w;
                out0->h = item.h;

                out1->x = x;
                out1->y = ny;
                out1->w = w;
                out1->h = h - item.h;
            }
            else
            {
                out0->x = nx;
                out0->y = y;
                out0->w = w - item.w;
                out0->h = h;

                out1->x = x;
                out1->y = ny;
                out1->w = item.w;
                out1->h = h - item.h;
            }
            w = item.w;
            h = item.h;
            i = item.i;
            return true;
        }
    };

    struct ResultBox {
        uint level;

        std::vector<ResultItem> items;
    };

    //  打包级别
    static constexpr iint PACK_LEVEL[][3] = {
        { 128, 128, 1 },
        { 256, 256, 2 },
        { 512, 512, 3 },
        { 1024, 1024, 4 },
        { 2048, 2048, 100 },
    };

    std::vector<ResultBox> Pack(std::vector<Item> items);

private:
    //  确定使用哪个级别打包图集
    uint CheckLevel(const Item & item);
    uint CheckLevel(const std::vector<Item> & items);
    //  根据图片的V值进行排序
    void SortItems(std::vector<Item> & items);
    void SortItems(std::vector<ResultItem> & items);
    uint CheckLimit(
        std::vector<ResultBox>::iterator cur,
        std::vector<ResultBox>::iterator end);
    //  打包
    ResultBox PackBox(
        std::vector<Item> & items, uint level);
    void PackBox(
        std::vector<Item> & items, uint level, std::vector<ResultBox> & retBoxs);
    //  解包
    void UnpackBox(std::vector<Item> & items, 
        std::vector<ResultBox>::iterator cur,
        std::vector<ResultBox>::iterator end);
};
//  storage_box.cpp
#include "storage_box.h"

std::vector<StorageBox::ResultBox> StorageBox::Pack(std::vector<Item> items)
{
    std::vector<ResultBox> retBoxs;

    PackBox(items, 0, retBoxs);

    for (auto it = retBoxs.begin(); it != retBoxs.end();)
    {
        auto level = it->level;
        auto limit = StorageBox::PACK_LEVEL[level][2];
        auto count = CheckLimit(it, retBoxs.end());
        if (count > limit)
        {
            UnpackBox(items, it, retBoxs.end());
            retBoxs.erase(it, retBoxs.end());
            PackBox(items, level+1, retBoxs);
            it = retBoxs.begin();
        }
        else
        {
            ++it;
        }
    }
    return retBoxs;
}

uint StorageBox::CheckLevel(const Item & item)
{
    for (auto i = 0; i != sizeof(PACK_LEVEL) / sizeof(PACK_LEVEL[0]); ++i)
    {
        if ((uint)PACK_LEVEL[i][0] >= item.w && 
            (uint)PACK_LEVEL[i][1] >= item.h)
        {
            return i;
        }
    }
    return (uint)~0;
}

uint StorageBox::CheckLevel(const std::vector<Item>& items)
{
    uint level = 0;
    for (auto & item : items)
    {
        auto i = CheckLevel(item);
        assert((uint)~0 != i);
        if (i > level) { level = i; }
    }
    return level;
}

void StorageBox::SortItems(std::vector<Item>& items)
{
    std::sort(items.begin(), items.end(), [](const Item & item0, const Item & item1)
        {
            return item0.GetV() > item1.GetV();
        });
}

void StorageBox::SortItems(std::vector<ResultItem> & items)
{
    std::sort(items.begin(), items.end(), [](const ResultItem & item0, const ResultItem & item1)
        {
            return item0.GetV() < item1.GetV();
        });
}

uint StorageBox::CheckLimit(std::vector<ResultBox>::iterator cur, std::vector<ResultBox>::iterator end)
{
    uint count = 0;
    uint level = cur->level;
    cur = std::next(cur);
    while (cur != end && cur->level == level)
    {
        ++cur; ++count;
    }
    return count;
}

StorageBox::ResultBox StorageBox::PackBox(std::vector<Item> & items, uint level)
{
    ResultBox retBox;
    retBox.level = level;

    std::vector<ResultItem> retItems;
    ResultItem retItem;
    retItem.i = (uint)~0;
    retItem.x = 0;
    retItem.y = 0;
    retItem.w = PACK_LEVEL[level][0];
    retItem.h = PACK_LEVEL[level][1];
    retItems.push_back(retItem);

    auto itemIndex = 0u;
    ResultItem retItem0;
    ResultItem retItem1;
    while (itemIndex != items.size())
    {
        auto isNewItem = false;
        for (auto it = retItems.begin(); it != retItems.end(); ++it)
        {
            if (it->AddItem(items.at(itemIndex), &retItem0, &retItem1))
            {
                isNewItem = true;

                //  添加到收纳箱
                retBox.items.push_back(*it);
                retItems.erase(it);

                //  新增2个新收纳箱
                retItems.push_back(retItem0);
                retItems.push_back(retItem1);
                SortItems(retItems);

                //  删除物品
                items.erase(items.begin() + itemIndex);
                break;
            }
        }
        if (!isNewItem) { ++itemIndex; }
    }
    return retBox;
}

void StorageBox::PackBox(std::vector<Item>& items, uint level, std::vector<ResultBox>& retBoxs)
{
    SortItems(items);
    while (!items.empty())
    {
        retBoxs.push_back(PackBox(items, level == 0? CheckLevel(items): level)); 
        level = 0;
    }
}

void StorageBox::UnpackBox(std::vector<Item> & items, std::vector<ResultBox>::iterator cur, std::vector<ResultBox>::iterator end)
{
    for (; cur != end; ++cur)
    {
        for (auto & retItem : cur->items)
        {
            if (retItem.IsReady())
            {
                Item item;
                item.i = retItem.i;
                item.w = retItem.w;
                item.h = retItem.h;
                items.push_back(item);
            }
        }
    }
}

这个算法并不能得到最优排列组合,但是这个算法简单而且在大多数情况下都够用。

posted @ 2019-05-11 01:52  落单的毛毛虫  阅读(682)  评论(1编辑  收藏