dust3d/src/regionfiller.cpp

#include <numeric>
#include <cmath>
#include <QDebug>
#include <set>
#include "regionfiller.h"

//
// This is an implementation of the following paper
//
// <Filling N-Sided Regions by Quad Meshes for Subdivision Surfaces>
// A. Nasri1∗, M. Sabin2 and Z. Yasseen1
//

#define isEven(n)   (0 == (n) % 2)
#define isOdd(n)    (!isEven(n))

RegionFiller::RegionFiller(const std::vector<Node> *vertices,
        const std::vector<std::vector<size_t>> *polylines) :
    m_sourceVertices(vertices),
    m_sourcePolylines(new std::vector<std::vector<size_t>>(*polylines))
{
}

RegionFiller::~RegionFiller()
{
    delete m_sourcePolylines;
}

bool RegionFiller::resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreEven()
{
    return resolveOddSidedEvenSumOfSegments(m_sideNum / 2);
}

std::vector<size_t> RegionFiller::createPointsToMapBetween(size_t fromIndex,
        size_t toIndex,
        size_t segments,
        std::map<std::pair<size_t, size_t>, std::vector<size_t>> *map)
{
    size_t a = fromIndex;
    size_t b = toIndex;
    bool needReverse = false;
    if (a > b) {
        std::swap(a, b);
        needReverse = true;
    }
    auto key = std::make_pair(a, b);
    auto findPoints = map->find(key);
    if (findPoints != map->end()) {
        return needReverse ? reversed(findPoints->second) : findPoints->second;
    }
    std::vector<size_t> newPointIndices;
    createPointsBetween(a, b, segments, &newPointIndices);
    map->insert({key, newPointIndices});
    return needReverse ? reversed(newPointIndices) : newPointIndices;
}

void RegionFiller::createPointsBetween(size_t fromIndex,
        size_t toIndex,
        size_t segments,
        std::vector<size_t> *newPointIndices)
{
    if (fromIndex == toIndex || 0 == segments)
        return;
    auto fromVertex = m_oldAndNewVertices[fromIndex];
    auto toVertex = m_oldAndNewVertices[toIndex];
    float stepFactor = 1.0 / segments;
    newPointIndices->push_back(fromIndex);
    for (size_t i = 1; i <= segments - 1; ++i) {
        float factor = stepFactor * i;
        RegionFiller::Node node;
        node.position = fromVertex.position * (1.0 - factor) + toVertex.position * factor;
        node.radius = fromVertex.radius * (1.0 - factor) + toVertex.radius * factor;
        if (m_centerSources.find(toVertex.source) != m_centerSources.end()) {
            node.source = fromVertex.source;
        } else if (m_centerSources.find(fromVertex.source) != m_centerSources.end()) {
            node.source = toVertex.source;
        } else {
            if (factor > 0.5) {
                node.source = toVertex.source;
            } else {
                node.source = fromVertex.source;
            }
        }
        size_t newIndex = m_oldAndNewVertices.size();
        m_oldAndNewVertices.push_back(node);
        newPointIndices->push_back(newIndex);
    }
    newPointIndices->push_back(toIndex);
}

std::vector<size_t> RegionFiller::createPointsBetween(size_t fromIndex,
        size_t toIndex,
        size_t segments)
{
    std::vector<size_t> newPointIndices;
    createPointsBetween(fromIndex, toIndex, segments, &newPointIndices);
    return newPointIndices;
}

void RegionFiller::collectEdgePoints(size_t polyline, int startPos, int stopPos,
    std::vector<size_t> *pointIndices)
{
    const auto &edgeIndices = (*m_sourcePolylines)[polyline];
    int step = startPos < stopPos ? 1 : -1;
    int totalSteps = std::abs(startPos - stopPos) + 1;
    int current = startPos;
    for (int i = 0; i < totalSteps; ++i) {
        pointIndices->push_back(edgeIndices[current]);
        current += step;
    }
}

std::vector<size_t> RegionFiller::collectEdgePoints(size_t polyline, int startPos, int stopPos)
{
    std::vector<size_t> pointIndices;
    collectEdgePoints(polyline, startPos, stopPos, &pointIndices);
    return pointIndices;
}

std::vector<size_t> RegionFiller::reversed(const std::vector<size_t> &pointIndices)
{
    std::vector<size_t> newPointIndices = pointIndices;
    std::reverse(newPointIndices.begin(), newPointIndices.end());
    return newPointIndices;
}

float RegionFiller::averageRadius(size_t *maxNodeIndex)
{
    float sumOfRadius = 0;
    size_t num = 0;
    float maxRadius = 0;
    for (const auto &polyline: *m_sourcePolylines) {
        for (const auto &it: polyline) {
            const auto &vertex = (*m_sourceVertices)[it];
            if (vertex.radius >= maxRadius) {
                maxRadius = vertex.radius;
                if (nullptr != maxNodeIndex)
                    *maxNodeIndex = it;
            }
            sumOfRadius += vertex.radius;
            ++num;
        }
    }
    if (0 == num)
        return 0;
    auto radius = sumOfRadius / num;
    return radius;
}

bool RegionFiller::resolveOddSidedEvenSumOfSegments(int siUpperBound)
{
    auto si = [&](int i) {
        int sum = 0;
        for (int j = 1; j <= siUpperBound; ++j) {
            sum += std::pow(-1, j + 1) *
                m_sideSegmentNums[(i + 2 * j - 1) % m_sideSegmentNums.size()];
        }
        return sum;
    };
    auto di = [&](int i) {
        return std::ceil(si(i) * 0.5);
    };
    
    std::vector<int> gRaySegmentNums(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        gRaySegmentNums[i] = di(i);
        if (gRaySegmentNums[i] <= 0) {
            qDebug() << "resolveOddSidedEvenSumOfSegments failed, di:" << gRaySegmentNums[i];
            return false;
        }
    }
 
    std::vector<int> eIndices(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        auto length = gRaySegmentNums[(i + 1) % gRaySegmentNums.size()];
        eIndices[i] = m_sideSegmentNums[i] - length;
    }
    
    std::set<size_t> cornerVertices;
    std::vector<std::tuple<int, int, int>> edgeSegments; // tuple<begin, end, edgeIndex>
    for (int i = 0; i < m_sideNum; ++i) {
        if (gRaySegmentNums[i] <= 0) {
            edgeSegments.push_back(std::make_tuple(0, (*m_sourcePolylines)[i].size() - 1, i));
            continue;
        }
        const auto &pointEdgeIndex = eIndices[i];
        cornerVertices.insert((*m_sourcePolylines)[i][pointEdgeIndex]);
        if (pointEdgeIndex > 0)
            edgeSegments.push_back(std::make_tuple(0, pointEdgeIndex, i));
        if (pointEdgeIndex < (int)(*m_sourcePolylines)[i].size() - 1)
            edgeSegments.push_back(std::make_tuple(pointEdgeIndex, (*m_sourcePolylines)[i].size() - 1, i));
    }
    
    std::vector<std::pair<QVector3D, float>> gPositionAndAreas;
    for (size_t i = 0; i < edgeSegments.size(); ++i) {
        size_t j = (i + 1) % edgeSegments.size();
        size_t m = (j + 2) % edgeSegments.size();
        const auto &segmentI = edgeSegments[i];
        const auto &segmentJ = edgeSegments[j];
        const auto &segmentM = edgeSegments[m];
        std::vector<size_t> firstSegmentPoints;
        std::vector<size_t> secondSegmentPoints;
        std::vector<size_t> forthSegmentPoints;
        collectEdgePoints(std::get<2>(segmentI), std::get<0>(segmentI), std::get<1>(segmentI),
            &firstSegmentPoints);
        collectEdgePoints(std::get<2>(segmentJ), std::get<0>(segmentJ), std::get<1>(segmentJ),
            &secondSegmentPoints);
        collectEdgePoints(std::get<2>(segmentM), std::get<0>(segmentM), std::get<1>(segmentM),
            &forthSegmentPoints);
        if (cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]) != cornerVertices.end() &&
                cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<1>(segmentI)]) != cornerVertices.end()) {
            const auto &p1 = (*m_sourceVertices)[(*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]];
            const auto &p2 = (*m_sourceVertices)[(*m_sourcePolylines)[std::get<2>(segmentI)][std::get<1>(segmentI)]];
            gPositionAndAreas.push_back(std::make_pair((p1.position + p2.position) * 0.5,
                (firstSegmentPoints.size() - 1) * (secondSegmentPoints.size() - 1) * 0.5));
            continue;
        }
        if (cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]) != cornerVertices.end() &&
                cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentJ)][std::get<1>(segmentJ)]) != cornerVertices.end()) {
            ++i;
            const auto &p1 = (*m_sourceVertices)[(*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]];
            const auto &p2 = (*m_sourceVertices)[(*m_sourcePolylines)[std::get<2>(segmentI)][std::get<1>(segmentI)]];
            const auto &p3 = (*m_sourceVertices)[(*m_sourcePolylines)[std::get<2>(segmentJ)][std::get<1>(segmentJ)]];
            gPositionAndAreas.push_back(std::make_pair(p1.position + p2.position - p3.position,
                (firstSegmentPoints.size() - 1) * (secondSegmentPoints.size() - 1)));
        }
    }
    
    QVector3D gTop;
    float gBottom = 0;
    for (const auto &it: gPositionAndAreas) {
        gTop += it.first / it.second;
        gBottom += 1.0 / it.second;
    }
    auto gPosition = gTop / gBottom;
    size_t gIndex = m_oldAndNewVertices.size();
    Node node;
    node.position = gPosition;
    node.radius = averageRadius(&node.source);
    m_centerSources.insert(node.source);
    m_oldAndNewVertices.push_back(node);
    
    std::map<std::pair<size_t, size_t>, std::vector<size_t>> map;
    for (size_t i = 0; i < edgeSegments.size(); ++i) {
        size_t j = (i + 1) % edgeSegments.size();
        size_t m = (j + 2) % edgeSegments.size();
        const auto &segmentI = edgeSegments[i];
        const auto &segmentJ = edgeSegments[j];
        const auto &segmentM = edgeSegments[m];
        std::vector<size_t> firstSegmentPoints;
        std::vector<size_t> secondSegmentPoints;
        std::vector<size_t> forthSegmentPoints;
        collectEdgePoints(std::get<2>(segmentI), std::get<0>(segmentI), std::get<1>(segmentI),
            &firstSegmentPoints);
        collectEdgePoints(std::get<2>(segmentJ), std::get<0>(segmentJ), std::get<1>(segmentJ),
            &secondSegmentPoints);
        collectEdgePoints(std::get<2>(segmentM), std::get<0>(segmentM), std::get<1>(segmentM),
            &forthSegmentPoints);
        if (cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]) != cornerVertices.end() &&
                cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<1>(segmentI)]) != cornerVertices.end()) {
            std::vector<std::vector<size_t>> region = {
                firstSegmentPoints,
                createPointsToMapBetween((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<1>(segmentI)],
                    gIndex, forthSegmentPoints.size() - 1, &map),
                createPointsToMapBetween(gIndex,
                    (*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)], secondSegmentPoints.size() - 1, &map)
            };
            m_newRegions.push_back(region);
            continue;
        }
        if (cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)]) != cornerVertices.end() &&
                cornerVertices.find((*m_sourcePolylines)[std::get<2>(segmentJ)][std::get<1>(segmentJ)]) != cornerVertices.end()) {
            ++i;
            std::vector<std::vector<size_t>> region = {
                firstSegmentPoints,
                secondSegmentPoints,
                createPointsToMapBetween((*m_sourcePolylines)[std::get<2>(segmentJ)][std::get<1>(segmentJ)],
                    gIndex, firstSegmentPoints.size() - 1, &map),
                createPointsToMapBetween(gIndex,
                    (*m_sourcePolylines)[std::get<2>(segmentI)][std::get<0>(segmentI)], secondSegmentPoints.size() - 1, &map)
            };
            m_newRegions.push_back(region);
        }
    }
    
    return true;
}

bool RegionFiller::resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreOdd()
{
    return resolveOddSidedOddSumOfSegments(m_sideNum / 2);
}

bool RegionFiller::resolveOddSidedOddSumOfSegments(int siUpperBound)
{
    auto si = [&](int i) {
        int sum = 0;
        for (int j = 1; j <= siUpperBound; ++j) {
            sum += std::pow(-1, j + 1) *
                (m_sideSegmentNums[(i + 2 * j - 1) % m_sideSegmentNums.size()] - 1);
        }
        return sum;
    };
    auto di = [&](int i) {
        return std::round(si(i) * 0.5);
    };
    std::vector<int> gRaySegmentNums(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        gRaySegmentNums[i] = di(i);
        if (gRaySegmentNums[i] <= 0) {
            qDebug() << "resolveOddSidedOddSumOfSegments failed, di:" << gRaySegmentNums[i];
            return false;
        }
    }
    
    std::vector<int> areas(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        areas[i] = gRaySegmentNums[i] * gRaySegmentNums[(i + 1) % m_sideNum];
    }
    
    std::vector<std::vector<int>> eIndices(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        auto length = gRaySegmentNums[(i + 1) % gRaySegmentNums.size()];
        eIndices[i] = std::vector<int>{(int)m_sideSegmentNums[i] - length - 1,
            (int)m_sideSegmentNums[i] - length
        };
        if (eIndices[i][0] < 0 || eIndices[i][1] < 0)
            return false;
    }
    std::vector<float> eEdgeLengths(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        eEdgeLengths[i] = ((*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][0]]].position -
                (*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][1]]].position).length();
    }
    float averageDislocationEdgeLength = std::accumulate(eEdgeLengths.begin(), eEdgeLengths.end(), 0.0) / eEdgeLengths.size();
    
    auto gi = [&](int i) {
        int j = (i + m_sideNum - 1) % m_sideNum;
        return (*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][0]]].position +
                (*m_sourceVertices)[(*m_sourcePolylines)[j][eIndices[j][1]]].position -
            (*m_sourceVertices)[(*m_sourcePolylines)[i][0]].position;
    };
    auto gOffsetTargets = [&](int i) {
        int h = (i + m_sideNum - 1) % m_sideNum;
        return ((*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][0]]].position +
                (*m_sourceVertices)[(*m_sourcePolylines)[h][eIndices[h][1]]].position) * 0.5;
    };
    
    QVector3D gTop;
    float gBottom = 0;
    for (int i = 0; i < m_sideNum; ++i) {
        gTop += gi(i) / areas[i];
        gBottom += 1.0 / areas[i];
    }
    
    auto gPosition = gTop / gBottom;
    size_t gSource = 0;
    auto gRadius = averageRadius(&gSource);
    m_centerSources.insert(gSource);
    
    std::vector<std::vector<std::vector<size_t>>> segmentsWithG(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        segmentsWithG[i].resize(2);
    }
    std::vector<size_t> gFace(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        int j = (i + 1) % m_sideNum;
        auto offsetTarget = gOffsetTargets(j);
        auto gPositionPerEdge = gPosition + (offsetTarget - gPosition).normalized() * averageDislocationEdgeLength * 0.7;
        size_t gIndex = m_oldAndNewVertices.size();
        gFace[j] = gIndex;
        Node node;
        node.position = gPositionPerEdge;
        node.radius = gRadius;
        node.source = gSource;
        m_oldAndNewVertices.push_back(node);
        createPointsBetween(gIndex, (*m_sourcePolylines)[i][eIndices[i][1]], gRaySegmentNums[i], &segmentsWithG[i][1]);
        createPointsBetween(gIndex, (*m_sourcePolylines)[j][eIndices[j][0]], gRaySegmentNums[j], &segmentsWithG[j][0]);
    }
    m_newFaces.push_back(gFace);
    
    std::vector<std::vector<std::vector<size_t>>> reversedSegmentsWithG(m_sideNum);
    reversedSegmentsWithG = segmentsWithG;
    for (int i = 0; i < m_sideNum; ++i) {
        for (int x = 0; x < 2; ++x)
            std::reverse(reversedSegmentsWithG[i][x].begin(), reversedSegmentsWithG[i][x].end());
    }
    
    for (int i = 0; i < m_sideNum; ++i) {
        int j = (i + 1) % m_sideNum;
        std::vector<size_t> e0c1;
        collectEdgePoints(i, eIndices[i][1], (*m_sourcePolylines)[i].size() - 1, &e0c1);
        std::vector<size_t> c1e1;
        collectEdgePoints(j, 0, eIndices[j][0], &c1e1);
        std::vector<std::vector<size_t>> region = {
            e0c1,
            c1e1,
            reversedSegmentsWithG[j][0],
            segmentsWithG[i][1]
        };
        m_newRegions.push_back(region);
    }
    
    // rectangle slices
    for (int i = 0; i < m_sideNum; ++i) {
        int j = (i + 1) % m_sideNum;
        std::vector<size_t> e1e2 = {
            (*m_sourcePolylines)[i][eIndices[i][0]],
            (*m_sourcePolylines)[i][eIndices[i][1]]
        };
        std::vector<size_t> gCoreEdge = {
            gFace[j],
            gFace[i]
        };
        std::vector<std::vector<size_t>> region = {
            e1e2,
            reversedSegmentsWithG[i][1],
            gCoreEdge,
            segmentsWithG[i][0],
        };
        m_newRegions.push_back(region);
    }
    
    return true;
}

bool RegionFiller::resolveEvenSideEvenSumOfSegmentsAndL1IsOddL2IsEven()
{
    std::rotate(m_sourcePolylines->begin(), m_sourcePolylines->begin() + 1, m_sourcePolylines->end());
    prepare();
    return resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd();
}

bool RegionFiller::resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd()
{
    auto modifiedSideSegmentNums = m_sideSegmentNums;
    for (int i = 0; i < m_sideNum; i += 2) {
        modifiedSideSegmentNums[i] -= 1;
    }
    
    auto si = [&](int i) {
        int sum = 0;
        int halfSideNum = m_sideNum / 2;
        for (int j = 1; j <= halfSideNum; ++j) {
            sum += std::pow(-1, j + 1) *
                (modifiedSideSegmentNums[(i + 2 * j - 1) % m_sideSegmentNums.size()]);
        }
        return sum;
    };
    auto di = [&](int i) {
        return std::round(si(i) * 0.5);
    };
    std::vector<int> gRaySegmentNums(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        gRaySegmentNums[i] = di(i);
        if (gRaySegmentNums[i] <= 0) {
            qDebug() << "resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd failed, di:" << gRaySegmentNums[i];
            return false;
        }
    }
    
    std::vector<int> areas(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        areas[i] = gRaySegmentNums[i] * gRaySegmentNums[(i + 1) % m_sideNum];
    }
    
    std::vector<std::vector<int>> eIndices(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        auto length = gRaySegmentNums[(i + gRaySegmentNums.size() - 1) % gRaySegmentNums.size()];
        if (0 == i % 2) {
            eIndices[i] = std::vector<int>{(int)length,
                (int)length + 1
            };
        } else {
            eIndices[i] = std::vector<int>{(int)length,
                (int)length
            };
        }
        if (eIndices[i][0] < 0 || eIndices[i][1] < 0) {
            qDebug() << "resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd failed";
            return false;
        }
    }
    std::vector<float> eEdgeLengths(m_sideNum, (float)0.0);
    int validEdgeNum = 0;
    for (int i = 0; i < m_sideNum; ++i) {
        const auto &firstIndex = eIndices[i][0];
        const auto &secondIndex = eIndices[i][1];
        if (firstIndex == secondIndex)
            continue;
        validEdgeNum++;
        eEdgeLengths[i] = ((*m_sourceVertices)[(*m_sourcePolylines)[i][firstIndex]].position -
                (*m_sourceVertices)[(*m_sourcePolylines)[i][secondIndex]].position).length();
    }
    float averageDislocationEdgeLength = std::accumulate(eEdgeLengths.begin(), eEdgeLengths.end(), 0.0) / validEdgeNum;
    
    auto gi = [&](int i) {
        int h = (i + m_sideNum - 1) % m_sideNum;
        return (*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][0]]].position +
                (*m_sourceVertices)[(*m_sourcePolylines)[h][eIndices[h][1]]].position -
            (*m_sourceVertices)[(*m_sourcePolylines)[i][0]].position;
    };
    auto gOffsetTargets = [&](int i) {
        int h = (i + m_sideNum - 1) % m_sideNum;
        return ((*m_sourceVertices)[(*m_sourcePolylines)[i][eIndices[i][0]]].position +
                (*m_sourceVertices)[(*m_sourcePolylines)[h][eIndices[h][1]]].position) * 0.5;
    };
    
    QVector3D gTop;
    float gBottom = 0;
    for (int i = 0; i < m_sideNum; ++i) {
        gTop += gi(i) / areas[i];
        gBottom += 1.0 / areas[i];
    }
    
    auto gPosition = gTop / gBottom;
    size_t gSource = 0;
    auto gRadius = averageRadius(&gSource);
    
    std::vector<size_t> gFace(m_sideNum / 2);
    for (size_t k = 0; k < gFace.size(); ++k) {
        int i = k * 2;
        int h = (i + m_sideNum - 1) % m_sideNum;
        auto offsetTarget = gOffsetTargets(i) * 0.5 + gOffsetTargets(h) * 0.5;
        size_t gIndex = m_oldAndNewVertices.size();
        auto gPositionPerEdge = gPosition + (offsetTarget - gPosition).normalized() * averageDislocationEdgeLength * 0.7;
        Node node;
        node.position = gPositionPerEdge;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
        gFace[k] = gIndex;
    }
    m_newFaces.push_back(gFace);
    
    std::vector<std::vector<std::vector<size_t>>> segmentsWithG(m_sideNum);
    for (int i = 0; i < m_sideNum; ++i) {
        segmentsWithG[i].resize(2);
    }
    for (int i = 0; i < m_sideNum; ++i) {
        int k = i / 2;
        const auto &g0Index = gFace[k % gFace.size()];
        const auto &g1Index = gFace[(k + 1) % gFace.size()];
        if (eIndices[i][0] == eIndices[i][1]) {
            createPointsBetween(g1Index, (*m_sourcePolylines)[i][eIndices[i][0]], gRaySegmentNums[i],
                &segmentsWithG[i][0]);
            segmentsWithG[i][1] = segmentsWithG[i][0];
        } else {
            createPointsBetween(g0Index, (*m_sourcePolylines)[i][eIndices[i][0]], gRaySegmentNums[i],
                &segmentsWithG[i][0]);
            createPointsBetween(g1Index, (*m_sourcePolylines)[i][eIndices[i][1]], gRaySegmentNums[i],
                &segmentsWithG[i][1]);
        }
    }
    
    std::vector<std::vector<std::vector<size_t>>> reversedSegmentsWithG(m_sideNum);
    reversedSegmentsWithG = segmentsWithG;
    for (int i = 0; i < m_sideNum; ++i) {
        for (int x = 0; x < 2; ++x)
            std::reverse(reversedSegmentsWithG[i][x].begin(), reversedSegmentsWithG[i][x].end());
    }
    
    for (int i = 0; i < m_sideNum; ++i) {
        int j = (i + 1) % m_sideNum;
        std::vector<size_t> e0c1;
        collectEdgePoints(i, eIndices[i][1], (*m_sourcePolylines)[i].size() - 1, &e0c1);
        std::vector<size_t> c1e1;
        collectEdgePoints(j, 0, eIndices[j][0], &c1e1);
        std::vector<std::vector<size_t>> region = {
            e0c1, c1e1, reversedSegmentsWithG[j][0], segmentsWithG[i][1]
        };
        m_newRegions.push_back(region);
    }
    
    // Rectangle slices
    for (size_t k = 0; k < gFace.size(); ++k) {
        int i = k * 2;
        std::vector<size_t> e1e2 = {
            (*m_sourcePolylines)[i][eIndices[i][0]],
            (*m_sourcePolylines)[i][eIndices[i][1]]
        };
        std::vector<size_t> g1g0 = {
            gFace[(k + 1) % gFace.size()],
            gFace[k % gFace.size()]
        };
        std::vector<std::vector<size_t>> region = {
            g1g0, segmentsWithG[i][0], e1e2, reversedSegmentsWithG[i][1]
        };
        m_newRegions.push_back(region);
    }
    
    return true;
}

bool RegionFiller::resolveQuadrilateralRegionMismatchSimilarCase(int m, int n, int p, int q, bool pqSwapped)
{
    return resolveQuadrilateralRegionWithIntegerSolution(m, n, p, q, pqSwapped);
}

bool RegionFiller::resolveQuadrilateralRegionWithNonIntegerSolution(int m, int n, int p, int q, bool pqSwapped)
{
    float aPlusB = m_sideSegmentNums[m] - m_sideSegmentNums[n];
    float aFloat = ((m_sideSegmentNums[m] - m_sideSegmentNums[n]) + (m_sideSegmentNums[p] - m_sideSegmentNums[q])) / 2.0;
    float bFloat = (m_sideSegmentNums[m] - m_sideSegmentNums[n]) - aFloat;
    float a = std::ceil(aFloat);
    float b = std::ceil(bFloat);
    
    int c0EdgeIndex = pqSwapped ? (*m_sourcePolylines)[m].size() - 1 : 0;
    int c1EdgeIndex = pqSwapped ? (*m_sourcePolylines)[p].size() - 1 : 0;
    int c2EdgeIndex = pqSwapped ? (*m_sourcePolylines)[n].size() - 1 : 0;
    int c3EdgeIndex = pqSwapped ? (*m_sourcePolylines)[q].size() - 1 : 0;
    
    int c0AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[q].size() - 1;
    int c1AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[m].size() - 1;
    int c2AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[p].size() - 1;
    int c3AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[n].size() - 1;
    
    const auto &c0Index = (*m_sourcePolylines)[m][c0EdgeIndex];
    const auto &c1Index = (*m_sourcePolylines)[p][c1EdgeIndex];
    
    const auto &c0 = (*m_sourceVertices)[c0Index].position;
    const auto &c1 = (*m_sourceVertices)[c1Index].position;

    int f0 = m_sideSegmentNums[n] / 2;
    int f1 = m_sideSegmentNums[n] - f0;
    int f2 = std::ceil((m_sideSegmentNums[p] - a) / 2.0);
    int f3 = m_sideSegmentNums[p] - a - f2;
    
    if (f3 < 0) {
        qDebug() << "resolveQuadrilateralRegionWithNonIntegerSolution failed, f3:" << f3;
        return false;
    }
    
    int e0EdgeIndex = f0;
    if (pqSwapped)
        e0EdgeIndex = (*m_sourcePolylines)[m].size() - 1 - e0EdgeIndex;
    const auto &e0Index = (*m_sourcePolylines)[m][e0EdgeIndex];
    
    int e2EdgeIndex = f0 + aPlusB;
    if (pqSwapped)
        e2EdgeIndex = (*m_sourcePolylines)[m].size() - 1 - e2EdgeIndex;
    const auto &e2Index = (*m_sourcePolylines)[m][e2EdgeIndex];
    
    int e3EdgeIndex = f2;
    if (pqSwapped)
        e3EdgeIndex = (*m_sourcePolylines)[p].size() - 1 - e3EdgeIndex;
    const auto &e3Index = (*m_sourcePolylines)[p][e3EdgeIndex];

    int e4EdgeIndex = (*m_sourcePolylines)[p].size() - 1 - f3;
    if (pqSwapped)
        e4EdgeIndex = (*m_sourcePolylines)[p].size() - 1 - e4EdgeIndex;
    const auto &e4Index = (*m_sourcePolylines)[p][e4EdgeIndex];
    
    int e5EdgeIndex = f3;
    if (pqSwapped)
        e5EdgeIndex = (*m_sourcePolylines)[q].size() - 1 - e5EdgeIndex;
    const auto &e5Index = (*m_sourcePolylines)[q][e5EdgeIndex];

    int e6EdgeIndex = (*m_sourcePolylines)[q].size() - 1 - f2;
    if (pqSwapped)
        e6EdgeIndex = (*m_sourcePolylines)[q].size() - 1 - e6EdgeIndex;
    const auto &e6Index = (*m_sourcePolylines)[q][e6EdgeIndex];

    int e7EdgeIndex = f1;
    if (pqSwapped)
        e7EdgeIndex = (*m_sourcePolylines)[n].size() - 1 - e7EdgeIndex;
    const auto &e7Index = (*m_sourcePolylines)[n][e7EdgeIndex];
    
    const auto &e0 = (*m_sourceVertices)[e0Index].position;
    const auto &e2 = (*m_sourceVertices)[e2Index].position;
    const auto &e3 = (*m_sourceVertices)[e3Index].position;
    const auto &e4 = (*m_sourceVertices)[e4Index].position;
    const auto &e5 = (*m_sourceVertices)[e5Index].position;
    const auto &e6 = (*m_sourceVertices)[e6Index].position;
    const auto &e7 = (*m_sourceVertices)[e7Index].position;
    
    auto g1InitialPosition = e0 + e6 - c0;
    auto g2InitialPosition = e2 + e3 - c1;
    auto gpInitialPosition1 = (e5 + e4) * 0.5;
    auto gpInitialPosition2 = gpInitialPosition1;
    auto g1a = f0 * f2;
    auto g2a = f1 * f2;
    auto gp1a = f0 * f3 + f0 * b;
    auto gp2a = f1 * f3 + f1 * a;
    
    float weightG1 = 1.0 / g1a;
    float weightG2 = 1.0 / g2a;
    float weightGp1 = 1.0 / gp1a;
    float weightGp2 = 1.0 / gp2a;
    
    size_t gSource = 0;
    auto gRadius = averageRadius(&gSource);
    
    auto gPosition = (g1InitialPosition * weightG1 +
            g2InitialPosition * weightG2 +
            gpInitialPosition1 * weightGp1 +
            gpInitialPosition2 * weightGp2) /
        (weightG1 + weightG2 + weightGp1 + weightGp2);
    
    auto averageOffsetDistance = e0.distanceToPoint(e2);
    
    auto g1Position = gPosition + (((e0 + e6) * 0.5) - gPosition).normalized() * averageOffsetDistance * 0.7;
    auto g2Position = gPosition + (((e2 + e3) * 0.5) - gPosition).normalized() * averageOffsetDistance * 0.7;
    auto gpPosition = gPosition + (e7 - gPosition).normalized() * averageOffsetDistance * 0.7;
    
    auto g1Index = m_oldAndNewVertices.size();
    {
        Node node;
        node.position = g1Position;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }
    
    auto g2Index = m_oldAndNewVertices.size();
    {
        Node node;
        node.position = g2Position;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }
    
    auto gpIndex = m_oldAndNewVertices.size();
    if (0 != f3) {
        Node node;
        node.position = gpPosition;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    } else {
        gpIndex = e7Index;
    }
    
    std::map<std::pair<size_t, size_t>, std::vector<size_t>> map;
    
    {
        std::vector<std::vector<size_t>> region = {
            collectEdgePoints(m, c0EdgeIndex, e0EdgeIndex),
            createPointsToMapBetween(e0Index, g1Index, f2, &map),
            createPointsToMapBetween(g1Index, e6Index, f0, &map),
            collectEdgePoints(q, e6EdgeIndex, c0AlternativeEdgeIndex)
        };
        m_newRegions.push_back(region);
    }
    
    {
        std::vector<std::vector<size_t>> region = {
            collectEdgePoints(m, e0EdgeIndex, e2EdgeIndex),
            createPointsToMapBetween(e2Index, g2Index, f2, &map),
            createPointsToMapBetween(g2Index, g1Index, aPlusB, &map),
            createPointsToMapBetween(g1Index, e0Index, f2, &map)
        };
        m_newRegions.push_back(region);
    }
    
    {
        std::vector<std::vector<size_t>> region = {
            collectEdgePoints(m, e2EdgeIndex, c1AlternativeEdgeIndex),
            collectEdgePoints(p, c1EdgeIndex, e3EdgeIndex),
            createPointsToMapBetween(e3Index, g2Index, f1, &map),
            createPointsToMapBetween(g2Index, e2Index, f2, &map)
        };
        m_newRegions.push_back(region);
    }
    
    if (gpIndex != e7Index) {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(g2Index, e3Index, f1, &map),
            collectEdgePoints(p, e3EdgeIndex, e4EdgeIndex),
            createPointsToMapBetween(e4Index, gpIndex, f1, &map),
            createPointsToMapBetween(gpIndex, g2Index, a, &map)
        };
        m_newRegions.push_back(region);
    } else {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(g2Index, e3Index, f1, &map),
            collectEdgePoints(p, e3EdgeIndex, c2AlternativeEdgeIndex),
            collectEdgePoints(n, c2EdgeIndex, e7EdgeIndex),
            createPointsToMapBetween(gpIndex, g2Index, a, &map)
        };
        m_newRegions.push_back(region);
    }
    
    if (gpIndex != e7Index) {
        std::vector<std::vector<size_t>> region = {
            collectEdgePoints(p, e4EdgeIndex, c2AlternativeEdgeIndex),
            collectEdgePoints(n, c2EdgeIndex, e7EdgeIndex),
            createPointsToMapBetween(e7Index, gpIndex, f3, &map),
            createPointsToMapBetween(gpIndex, e4Index, f1, &map)
        };
        m_newRegions.push_back(region);
    }
    
    if (gpIndex != e7Index) {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(gpIndex, e7Index, f3, &map),
            collectEdgePoints(n, e7EdgeIndex, c3AlternativeEdgeIndex),
            collectEdgePoints(q, c3EdgeIndex, e5EdgeIndex),
            createPointsToMapBetween(e5Index, gpIndex, f0, &map)
        };
        m_newRegions.push_back(region);
    }
    
    if (gpIndex != e7Index) {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(g1Index, gpIndex, b, &map),
            createPointsToMapBetween(gpIndex, e5Index, f0, &map),
            collectEdgePoints(q, e5EdgeIndex, e6EdgeIndex),
            createPointsToMapBetween(e6Index, g1Index, f0, &map)
        };
        m_newRegions.push_back(region);
    } else {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(g1Index, gpIndex, b, &map),
            collectEdgePoints(n, e7EdgeIndex, c3AlternativeEdgeIndex),
            collectEdgePoints(q, c3EdgeIndex, e6EdgeIndex),
            createPointsToMapBetween(e6Index, g1Index, f0, &map)
        };
        m_newRegions.push_back(region);
    }
    {
        std::vector<std::vector<size_t>> region = {
            createPointsToMapBetween(g1Index, g2Index, aPlusB, &map),
            createPointsToMapBetween(g2Index, gpIndex, a, &map),
            createPointsToMapBetween(gpIndex, g1Index, b, &map)
        };
        m_newRegions.push_back(region);
    }
    return true;
}

bool RegionFiller::resolveQuadrilateralRegionWithIntegerSolution(int m, int n, int p, int q, bool pqSwapped)
{
    // a + b = m − n
    // a − b = p − q
    // (a + b) + (a - b) = (m - n) + (p - q)
    // a = ((m - n) + (p - q)) / 2

    int a = ((m_sideSegmentNums[m] - m_sideSegmentNums[n]) + (m_sideSegmentNums[p] - m_sideSegmentNums[q])) / 2;
    int b = (m_sideSegmentNums[m] - m_sideSegmentNums[n]) - a;
    
    bool isMismatchSimilar = 0 == b;

    int f0 = m_sideSegmentNums[n] / 2;
    int f1 = m_sideSegmentNums[n] - f0;
    int f2 = (m_sideSegmentNums[q] - b) / 2;
    int f3 = m_sideSegmentNums[q] - b - f2;
    
    if (f3 < 0) {
        qDebug() << "resolveQuadrilateralRegionWithIntegerSolution failed, f3:" << f3;
        return false;
    }

    float a1 = f0 * f2;
    float a2 = f0 * b;
    float a3 = f0 * f3;
    float a4 = f1 * f2;
    float a5 = f1 * a;
    float a6 = f1 * f3;
    float a7 = a * f2;
    float a8 = b * f2;
    float a9 = a * b;
    
    int c0EdgeIndex = pqSwapped ? (*m_sourcePolylines)[m].size() - 1 : 0;
    int c1EdgeIndex = pqSwapped ? (*m_sourcePolylines)[p].size() - 1 : 0;
    int c2EdgeIndex = pqSwapped ? (*m_sourcePolylines)[n].size() - 1 : 0;
    int c3EdgeIndex = pqSwapped ? (*m_sourcePolylines)[q].size() - 1 : 0;
    
    int c0AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[q].size() - 1;
    int c1AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[m].size() - 1;
    int c2AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[p].size() - 1;
    int c3AlternativeEdgeIndex = pqSwapped ? 0 : (*m_sourcePolylines)[n].size() - 1;

    const auto &c0Index = (*m_sourcePolylines)[m][c0EdgeIndex];
    const auto &c1Index = (*m_sourcePolylines)[p][c1EdgeIndex];
    const auto &c2Index = (*m_sourcePolylines)[n][c2EdgeIndex];
    const auto &c3Index = (*m_sourcePolylines)[q][c3EdgeIndex];

    const auto &c0 = (*m_sourceVertices)[c0Index].position;
    const auto &c1 = (*m_sourceVertices)[c1Index].position;
    const auto &c2 = (*m_sourceVertices)[c2Index].position;
    const auto &c3 = (*m_sourceVertices)[c3Index].position;

    int e0EdgeIndex = f0;
    if (pqSwapped)
        e0EdgeIndex = (*m_sourcePolylines)[m].size() - 1 - e0EdgeIndex;
    const auto &e0Index = (*m_sourcePolylines)[m][e0EdgeIndex];

    int e1EdgeIndex = f0 + a;
    if (pqSwapped)
        e1EdgeIndex = (*m_sourcePolylines)[m].size() - 1 - e1EdgeIndex;
    const auto &e1Index = (*m_sourcePolylines)[m][e1EdgeIndex];

    int e2EdgeIndex = f0 + a + b;
    if (pqSwapped)
        e2EdgeIndex = (*m_sourcePolylines)[m].size() - 1 - e2EdgeIndex;
    const auto &e2Index = (*m_sourcePolylines)[m][e2EdgeIndex];

    int e3EdgeIndex = f2;
    if (pqSwapped)
        e3EdgeIndex = (*m_sourcePolylines)[p].size() - 1 - e3EdgeIndex;
    const auto &e3Index = (*m_sourcePolylines)[p][e3EdgeIndex];

    int e4EdgeIndex = f2 + a;
    if (pqSwapped)
        e4EdgeIndex = (*m_sourcePolylines)[p].size() - 1 - e4EdgeIndex;
    const auto &e4Index = (*m_sourcePolylines)[p][e4EdgeIndex];

    int e5EdgeIndex = f3;
    if (pqSwapped)
        e5EdgeIndex = (*m_sourcePolylines)[q].size() - 1 - e5EdgeIndex;
    const auto &e5Index = (*m_sourcePolylines)[q][e5EdgeIndex];

    int e6EdgeIndex = f3 + b;
    if (pqSwapped)
        e6EdgeIndex = (*m_sourcePolylines)[q].size() - 1 - e6EdgeIndex;
    const auto &e6Index = (*m_sourcePolylines)[q][e6EdgeIndex];

    int e7EdgeIndex = f1;
    if (pqSwapped)
        e7EdgeIndex = (*m_sourcePolylines)[n].size() - 1 - e7EdgeIndex;
    const auto &e7Index = (*m_sourcePolylines)[n][e7EdgeIndex];

    const auto &e0 = (*m_sourceVertices)[e0Index].position;
    const auto &e1 = (*m_sourceVertices)[e1Index].position;
    const auto &e2 = (*m_sourceVertices)[e2Index].position;
    const auto &e3 = (*m_sourceVertices)[e3Index].position;
    const auto &e4 = (*m_sourceVertices)[e4Index].position;
    const auto &e5 = (*m_sourceVertices)[e5Index].position;
    const auto &e6 = (*m_sourceVertices)[e6Index].position;
    const auto &e7 = (*m_sourceVertices)[e7Index].position;

    auto g1 = e1 + e5 - c0;
    auto gn = e1 + e4 - c1;
    auto g2 = e4 + e7 - c2;
    auto gp = e5 + e7 - c3;

    auto weight1 = 1.0 / (a1 + a2 + a7 + a9);
    auto weightn = 1.0 / (a4 + a5 + a8 + a9);
    auto weight2 = 1.0 / (a6);
    auto weightp = 1.0 / (a3);

    auto gPosition = (g1 * weight1 + gn * weightn + g2 * weight2 + gp * weightp) /
        (weight1 + weightn + weight2 + weightp);
    
    size_t gSource = 0;
    auto gRadius = averageRadius(&gSource);

    auto averageOffsetDistance = e0.distanceToPoint(e2);
    if (!isMismatchSimilar)
        averageOffsetDistance *= 0.5;
    auto g1Position = gPosition + (e6 - gPosition).normalized() * averageOffsetDistance * 0.7;
    auto gnPosition = gPosition + (e1 - gPosition).normalized() * averageOffsetDistance * 0.7;
    auto g2Position = gPosition + (e3 - gPosition).normalized() * averageOffsetDistance * 0.7;
    auto gpPosition = gPosition + (e7 - gPosition).normalized() * averageOffsetDistance * 0.7;
    
    if (isMismatchSimilar) {
        gpPosition = ((*m_sourceVertices)[e0Index].position +
            (*m_sourceVertices)[e5Index].position +
            (*m_sourceVertices)[e7Index].position +
            (*m_sourceVertices)[e4Index].position) / 4.0;
        gnPosition = ((*m_sourceVertices)[e0Index].position +
            gpPosition +
            (*m_sourceVertices)[e3Index].position +
            (*m_sourceVertices)[c1Index].position) / 4.0;
    }

    size_t g1Index = m_oldAndNewVertices.size();
    if (!isMismatchSimilar) {
        Node node;
        node.position = g1Position;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }

    size_t gnIndex = m_oldAndNewVertices.size();
    {
        Node node;
        node.position = gnPosition;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }
    
    size_t g2Index = m_oldAndNewVertices.size();
    if (!isMismatchSimilar) {
        Node node;
        node.position = g2Position;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }

    size_t gpIndex = m_oldAndNewVertices.size();
    {
        Node node;
        node.position = gpPosition;
        node.radius = gRadius;
        node.source = gSource;
        m_centerSources.insert(node.source);
        m_oldAndNewVertices.push_back(node);
    }
    
    if (isMismatchSimilar) {
        g1Index = gpIndex;
        g2Index = gnIndex;
    }
    
    std::map<std::pair<size_t, size_t>, std::vector<size_t>> map;
    
    std::vector<std::vector<size_t>> region1 = {
        collectEdgePoints(m, c0EdgeIndex, e0EdgeIndex),
        createPointsToMapBetween(e0Index, g1Index, f2, &map),
        createPointsToMapBetween(g1Index, e6Index, f0, &map),
        collectEdgePoints(q, e6EdgeIndex, c0AlternativeEdgeIndex)
    };
    m_newRegions.push_back(region1);
    
    if (e5Index != e6Index) {
        std::vector<std::vector<size_t>> region2 = {
            createPointsToMapBetween(e6Index, g1Index, f0, &map),
            createPointsToMapBetween(g1Index, gpIndex, b, &map),
            createPointsToMapBetween(gpIndex, e5Index, f0, &map),
            collectEdgePoints(q, e5EdgeIndex, e6EdgeIndex)
        };
        m_newRegions.push_back(region2);
    }
    
    std::vector<std::vector<size_t>> region3 = {
        createPointsToMapBetween(e5Index, gpIndex, f0, &map),
        createPointsToMapBetween(gpIndex, e7Index, f3, &map),
        collectEdgePoints(n, e7EdgeIndex, c3AlternativeEdgeIndex),
        collectEdgePoints(q, c3EdgeIndex, e5EdgeIndex)
    };
    m_newRegions.push_back(region3);
    
    std::vector<std::vector<size_t>> region4 = {
        collectEdgePoints(m, e2EdgeIndex, c1AlternativeEdgeIndex),
        collectEdgePoints(p, c1EdgeIndex, e3EdgeIndex),
        createPointsToMapBetween(e3Index, g2Index, f1, &map),
        createPointsToMapBetween(g2Index, e2Index, f2, &map)
    };
    m_newRegions.push_back(region4);
    
    if (e3Index != e4Index) {
        std::vector<std::vector<size_t>> region5 = {
            createPointsToMapBetween(g2Index, e3Index, f1, &map),
            collectEdgePoints(p, e3EdgeIndex, e4EdgeIndex),
            createPointsToMapBetween(e4Index, gpIndex, f1, &map),
            createPointsToMapBetween(gpIndex, g2Index, a, &map)
        };
        m_newRegions.push_back(region5);
    }
    
    std::vector<std::vector<size_t>> region6 = {
        createPointsToMapBetween(gpIndex, e4Index, f1, &map),
        collectEdgePoints(p, e4EdgeIndex, c2AlternativeEdgeIndex),
        collectEdgePoints(n, c2EdgeIndex, e7EdgeIndex),
        createPointsToMapBetween(e7Index, gpIndex, f3, &map)
    };
    m_newRegions.push_back(region6);
    
    if (g1Index != gnIndex && e0Index != e1Index) {
        std::vector<std::vector<size_t>> region7 = {
            collectEdgePoints(m, e0EdgeIndex, e1EdgeIndex),
            createPointsToMapBetween(e1Index, gnIndex, f2, &map),
            createPointsToMapBetween(gnIndex, g1Index, a, &map),
            createPointsToMapBetween(g1Index, e0Index, f2, &map)
        };
        m_newRegions.push_back(region7);
    }
    
    if (g2Index != gnIndex && e1Index != e2Index) {
        std::vector<std::vector<size_t>> region8 = {
            collectEdgePoints(m, e1EdgeIndex, e2EdgeIndex),
            createPointsToMapBetween(e2Index, g2Index, f2, &map),
            createPointsToMapBetween(g2Index, gnIndex, b, &map),
            createPointsToMapBetween(gnIndex, e1Index, f2, &map)
        };
        m_newRegions.push_back(region8);
    }
    
    if (!isMismatchSimilar) {
        std::vector<std::vector<size_t>> region9 = {
            createPointsToMapBetween(g1Index, gnIndex, a, &map),
            createPointsToMapBetween(gnIndex, g2Index, b, &map),
            createPointsToMapBetween(g2Index, gpIndex, a, &map),
            createPointsToMapBetween(gpIndex, g1Index, b, &map)
        };
        m_newRegions.push_back(region9);
    }
    
    return true;
}

bool RegionFiller::resolveQuadrilateralRegion()
{
    int diff02 = std::abs(m_sideSegmentNums[0] - m_sideSegmentNums[2]);
    int diff13 = std::abs(m_sideSegmentNums[1] - m_sideSegmentNums[3]);
    int m, n, p, q;
    if (diff02 >= diff13) {
        if (m_sideSegmentNums[0] > m_sideSegmentNums[2]) {
            m = 0;
            n = 2;
            p = 1;
            q = 3;
        } else {
            m = 2;
            n = 0;
            p = 3;
            q = 1;
        }
    } else {
        if (m_sideSegmentNums[1] > m_sideSegmentNums[3]) {
            m = 1;
            n = 3;
            p = 2;
            q = 0;
        } else {
            m = 3;
            n = 1;
            p = 0;
            q = 2;
        }
    }
    bool pqSwapped = false;
    if (m_sideSegmentNums[p] < m_sideSegmentNums[q]) {
        std::swap(p, q);
        pqSwapped = true;
    }
    if (diff02 != diff13) {
        if (isEven(m_sumOfSegments)) {
            return resolveQuadrilateralRegionWithIntegerSolution(m, n, p, q, pqSwapped);
        } else {
            return resolveQuadrilateralRegionWithNonIntegerSolution(m, n, p, q, pqSwapped);
        }
    } else {
        return resolveQuadrilateralRegionMismatchSimilarCase(m, n, p, q, pqSwapped);
    }
}

const std::vector<RegionFiller::Node> &RegionFiller::getOldAndNewVertices()
{
    return m_oldAndNewVertices;
}

const std::vector<std::vector<size_t>> &RegionFiller::getNewFaces()
{
    return m_newFaces;
}

void RegionFiller::prepare()
{
    m_sideNum = m_sourcePolylines->size();
    m_sideSegmentNums.clear();
    for (const auto &it: *m_sourcePolylines) {
        auto l = (int)it.size() - 1;
        m_sideSegmentNums.push_back(l);
    }
    m_sumOfSegments = std::accumulate(m_sideSegmentNums.begin(), m_sideSegmentNums.end(), 0);
}

bool RegionFiller::resolveQuadrilateralRegionDirectCase()
{
    std::vector<std::vector<size_t>> region = {
        collectEdgePoints(0, 0, (*m_sourcePolylines)[0].size() - 1),
        collectEdgePoints(1, 0, (*m_sourcePolylines)[1].size() - 1),
        collectEdgePoints(2, 0, (*m_sourcePolylines)[2].size() - 1),
        collectEdgePoints(3, 0, (*m_sourcePolylines)[3].size() - 1)
    };
    m_newRegions.push_back(region);
    return true;
}

void RegionFiller::fillWithoutPartition()
{
    m_oldAndNewVertices = *m_sourceVertices;
    m_newFaces.clear();
    convertPolylinesToFaces();
}

bool RegionFiller::fill()
{
    m_oldAndNewVertices = *m_sourceVertices;
    
    prepare();
    
    if (4 == m_sideNum) {
        if (m_sideSegmentNums[0] == m_sideSegmentNums[2] &&
                m_sideSegmentNums[1] == m_sideSegmentNums[3]) {
            if (!resolveQuadrilateralRegionDirectCase()) {
                qDebug() << "resolveQuadrilateralRegionDirectCase failed";
                return false;
            }
        } else {
            if (!resolveQuadrilateralRegion()) {
                qDebug() << "resolveQuadrilateralRegion failed";
                return false;
            }
        }
    } else {
        if (isOdd(m_sideNum)) {
            if (isEven(m_sumOfSegments)) {
                if (!resolveOddSidedEvenSumOfSegments(m_sideNum)) {
                    qDebug() << "resolveOddSidedEvenSumOfSegments failed, m_sideNum:" << m_sideNum;
                    return false;
                }
            } else {
                if (!resolveOddSidedOddSumOfSegments(m_sideNum)) {
                    qDebug() << "resolveOddSidedOddSumOfSegments failed, m_sideNum:" << m_sideNum;
                    return false;
                }
            }
        } else {
            int l1 = 0;
            int l2 = 0;
            
            int halfSideNum = m_sideNum / 2;
            
            for (int i = 1; i <= halfSideNum; ++i) {
                l1 += m_sideSegmentNums[(i * 2 - 1) % m_sideNum];
                l2 += m_sideSegmentNums[(i * 2 - 1 - 1) % m_sideNum];
            }

            if (isEven(l1) && isEven(l2)) {
                if (!resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreEven()) {
                    qDebug() << "resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreEven failed";
                    return false;
                }
            } else if (isOdd(l1) && isOdd(l2)) {
                if (!resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreOdd()) {
                    qDebug() << "resolveEvenSidedEvenSumOfSegmentsAndBothL2L2AreOdd failed";
                    return false;
                }
            } else if (isEven(l1) && isOdd(l2)) {
                if (!resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd()) {
                    qDebug() << "resolveEvenSideEvenSumOfSegmentsAndL1IsEvenL2IsOdd failed";
                    return false;
                }
            } else {
                if (!resolveEvenSideEvenSumOfSegmentsAndL1IsOddL2IsEven()) {
                    qDebug() << "resolveEvenSideEvenSumOfSegmentsAndL1IsOddL2IsEven failed";
                    return false;
                }
            }
        }
    }
    
    if (!convertRegionsToPatches()) {
        qDebug() << "convertRegionsToPatches failed";
        return false;
    }
    
    return true;
}

void RegionFiller::convertRegionsToFaces()
{
    if (m_newRegions.empty()) {
        qDebug() << "No region, should not happen";
        return;
    }
    
    for (const auto &region: m_newRegions) {
        std::vector<size_t> face;
        for (const auto &line: region) {
            for (size_t i = 1; i < line.size(); ++i) {
                face.push_back(line[i]);
            }
        }
        if (face.size() < 3) {
            qDebug() << "Face length invalid:" << face.size();
            continue;
        }
        m_newFaces.push_back(face);
    }
}

void RegionFiller::convertPolylinesToFaces()
{
    if (m_sourcePolylines->empty())
        return;
    
    std::vector<size_t> face;
    for (const auto &line: *m_sourcePolylines) {
        for (size_t i = 1; i < line.size(); ++i) {
            face.push_back(line[i]);
        }
    }
    if (face.size() < 3) {
        return;
    }
    m_newFaces.push_back(face);
}

bool RegionFiller::createCoonsPatchFrom(const std::vector<size_t> &c0,
        const std::vector<size_t> &c1,
        const std::vector<size_t> &d0,
        const std::vector<size_t> &d1,
        bool fillLastTriangle)
{
    auto Lc_Position = [&](int s, int t) {
        float factor = (float)t / d0.size();
        return (1.0 - factor) * m_oldAndNewVertices[c0[s]].position + factor * m_oldAndNewVertices[c1[s]].position;
    };
    auto Ld_Position = [&](int s, int t) {
        float factor = (float)s / c0.size();
        return (1.0 - factor) * m_oldAndNewVertices[d0[t]].position + factor * m_oldAndNewVertices[d1[t]].position;
    };
    auto B_Position = [&](int s, int t) {
        float tFactor = (float)t / d0.size();
        float sFactor = (float)s / c0.size();
        return m_oldAndNewVertices[c0[0]].position * (1.0 - sFactor) * (1.0 - tFactor) +
            m_oldAndNewVertices[c0[c0.size() - 1]].position * sFactor * (1.0 - tFactor) +
            m_oldAndNewVertices[c1[0]].position * (1.0 - sFactor) * tFactor +
            m_oldAndNewVertices[c1[c1.size() - 1]].position * sFactor * tFactor;
    };
    auto C_Position = [&](int s, int t) {
        return Lc_Position(s, t) + Ld_Position(s, t) - B_Position(s, t);
    };
    
    auto Lc_Radius = [&](int s, int t) {
        float factor = (float)t / d0.size();
        return (1.0 - factor) * m_oldAndNewVertices[c0[s]].radius + factor * m_oldAndNewVertices[c1[s]].radius;
    };
    auto Ld_Radius = [&](int s, int t) {
        float factor = (float)s / c0.size();
        return (1.0 - factor) * m_oldAndNewVertices[d0[t]].radius + factor * m_oldAndNewVertices[d1[t]].radius;
    };
    auto B_Radius = [&](int s, int t) {
        float tFactor = (float)t / d0.size();
        float sFactor = (float)s / c0.size();
        return m_oldAndNewVertices[c0[0]].radius * (1.0 - sFactor) * (1.0 - tFactor) +
            m_oldAndNewVertices[c0[c0.size() - 1]].radius * sFactor * (1.0 - tFactor) +
            m_oldAndNewVertices[c1[0]].radius * (1.0 - sFactor) * tFactor +
            m_oldAndNewVertices[c1[c1.size() - 1]].radius * sFactor * tFactor;
    };
    auto C_Radius = [&](int s, int t) {
        return Lc_Radius(s, t) + Ld_Radius(s, t) - B_Radius(s, t);
    };
    
    auto getSource = [&](size_t i, size_t j, float factor) {
        if (m_centerSources.find(m_oldAndNewVertices[j].source) != m_centerSources.end()) {
            return m_oldAndNewVertices[i].source;
        } else if (m_centerSources.find(m_oldAndNewVertices[i].source) != m_centerSources.end()) {
            return m_oldAndNewVertices[j].source;
        } else {
            if (factor > 0.5) {
                return m_oldAndNewVertices[j].source;
            }
            return m_oldAndNewVertices[i].source;
        }
    };
    
    auto Lc_Source = [&](int s, int t) {
        float factor = (float)t / d0.size();
        return getSource(c0[s], c1[s], factor);
    };
    auto C_Source = [&](int s, int t) {
        return Lc_Source(s, t);
    };
    
    std::vector<std::vector<size_t>> grid(c0.size());
    for (int s = 1; s < (int)c0.size() - 1; ++s) {
        grid[s].resize(d0.size());
        for (int t = 1; t < (int)d0.size() - 1; ++t) {
            Node node;
            node.position = C_Position(s, t);
            node.radius = C_Radius(s, t);
            node.source = C_Source(s, t);
            grid[s][t] = m_oldAndNewVertices.size();
            m_oldAndNewVertices.push_back(node);
        }
    }
    grid[0].resize(d0.size());
    grid[c0.size() - 1].resize(d0.size());
    for (size_t i = 0; i < c0.size(); ++i) {
        grid[i][0] = c0[i];
        grid[i][d0.size() - 1] = c1[i];
    }
    for (size_t i = 0; i < d0.size(); ++i) {
        grid[0][i] = d0[i];
        grid[c0.size() - 1][i] = d1[i];
    }
    for (int s = 1; s < (int)c0.size(); ++s) {
        for (int t = 1; t < (int)d0.size(); ++t) {
            std::vector<size_t> face = {
                grid[s - 1][t - 1],
                grid[s - 1][t],
                grid[s][t],
                grid[s][t - 1]
            };
            m_newFaces.push_back(face);
        }
    }
    if (fillLastTriangle) {
        std::vector<size_t> face = {
            grid[c0.size() - 1][d0.size() - 2],
            grid[c0.size() - 2][d0.size() - 2],
            grid[c0.size() - 2][d0.size() - 1]
        };
        m_newFaces.push_back(face);
    }
    return true;
}

bool RegionFiller::createCoonsPatch(const std::vector<std::vector<size_t>> &region)
{
    // https://en.wikipedia.org/wiki/Coons_patch
    if (region.size() != 4) {
        if (region.size() == 3) {
            createCoonsPatchThreeSidedRegion(region);
            return true;
        }
        qDebug() << "Invalid region edges:" << region.size();
        return false;
    }
    const auto &c0 = region[0];
    auto c1 = region[2];
    std::reverse(c1.begin(), c1.end());
    const auto &d1 = region[1];
    auto d0 = region[3];
    std::reverse(d0.begin(), d0.end());
    if (c0.empty() ||
            c0.size() != c1.size() ||
        d0.empty() ||
            d0.size() != d1.size()) {
        qDebug() << "Invalid region size:" << c0.size() << c1.size() << d0.size() << d1.size();
        return false;
    }
    return createCoonsPatchFrom(c0, c1, d0, d1, false);
}

bool RegionFiller::createCoonsPatchThreeSidedRegion(const std::vector<std::vector<size_t>> &region)
{
    if (region.size() != 3) {
        qDebug() << "Not three sided region";
        return false;
    }

    int longest = 0;
    size_t longestLength = region[longest].size();
    for (int i = 1; i < 3; ++i) {
        if (region[i].size() > longestLength) {
            longest = i;
            longestLength = region[i].size();
        }
    }
    
    int c = longest;
    int a = (c + 1) % 3;
    int b = (a + 1) % 3;
    
    auto c0 = region[a];
    std::reverse(c0.begin(), c0.end());
    auto c1 = std::vector<size_t>(region[c].begin(), region[c].begin() + c0.size());
    
    auto d0 = region[b];
    auto d1 = std::vector<size_t>(region[c].begin() + region[c].size() - d0.size(), region[c].begin() + region[c].size());
    std::reverse(d1.begin(), d1.end());
    
    bool fillTriangle = region[c].size() != region[a].size() &&
        region[a].size() != region[b].size();
    if (c0.size() < d0.size()) {
        if (!createCoonsPatchFrom(d0, d1, c0, c1, fillTriangle))
            return false;
    } else {
        if (!createCoonsPatchFrom(c0, c1, d0, d1, fillTriangle))
            return false;
    }
    
    return true;
}

bool RegionFiller::convertRegionsToPatches()
{
    if (m_newRegions.empty()) {
        qDebug() << "No region, should not happen";
        return false;
    }
    for (const auto &region: m_newRegions) {
        if (!createCoonsPatch(region))
            return false;
    }
    
    return true;
}