DiffVG/sample_boundary.h

#pragma once

#include "diffvg.h"
#include "shape.h"
#include "scene.h"
#include "vector.h"
#include "cdf.h"

struct PathBoundaryData {
    int base_point_id;
    int point_id;
    float t;
};

struct BoundaryData {
    PathBoundaryData path;
    bool is_stroke;
};

DEVICE
Vector2f sample_boundary(const Circle &circle,
                         float t,
                         Vector2f &normal,
                         float &pdf,
                         BoundaryData &,
                         float stroke_perturb_direction,
                         float stroke_radius) {
    // Parametric form of a circle (t in [0, 1)):
    // x = center.x + r * cos(2pi * t)
    // y = center.y + r * sin(2pi * t)
    auto offset = Vector2f{
        circle.radius * cos(2 * float(M_PI) * t),
        circle.radius * sin(2 * float(M_PI) * t)
    };
    normal = normalize(offset);
    pdf /= (2 * float(M_PI) * circle.radius);
    auto ret = circle.center + offset;
    if (stroke_perturb_direction != 0.f) {
        ret += stroke_perturb_direction * stroke_radius * normal;
        if (stroke_perturb_direction < 0) {
            // normal should point towards the perturb direction
            normal = -normal;
        }
    }
    return ret;
}

DEVICE
Vector2f sample_boundary(const Ellipse &ellipse,
                         float t,
                         Vector2f &normal,
                         float &pdf,
                         BoundaryData &,
                         float stroke_perturb_direction,
                         float stroke_radius) {
    // Parametric form of a ellipse (t in [0, 1)):
    // x = center.x + r.x * cos(2pi * t)
    // y = center.y + r.y * sin(2pi * t)
    const auto &r = ellipse.radius;
    auto offset = Vector2f{
        r.x * cos(2 * float(M_PI) * t),
        r.y * sin(2 * float(M_PI) * t)
    };
    auto dxdt = -r.x * sin(2 * float(M_PI) * t) * 2 * float(M_PI);
    auto dydt = r.y * cos(2 * float(M_PI) * t) * 2 * float(M_PI);
    // tangent is normalize(dxdt, dydt)
    normal = normalize(Vector2f{dydt, -dxdt});
    pdf /= sqrt(square(dxdt) + square(dydt));
    auto ret = ellipse.center + offset;
    if (stroke_perturb_direction != 0.f) {
        ret += stroke_perturb_direction * stroke_radius * normal;
        if (stroke_perturb_direction < 0) {
            // normal should point towards the perturb direction
            normal = -normal;
        }
    }
    return ret;
}

DEVICE
Vector2f sample_boundary(const Path &path,
                         const float *path_length_cdf,
                         const float *path_length_pmf,
                         const int *point_id_map,
                         float path_length,
                         float t,
                         Vector2f &normal,
                         float &pdf,
                         BoundaryData &data,
                         float stroke_perturb_direction,
                         float stroke_radius) {
    if (stroke_perturb_direction != 0.f && !path.is_closed) {
        // We need to samples the "caps" of the path
        // length of a cap is pi * abs(stroke_perturb_direction)
        // there are two caps
        auto cap_length = 0.f;
        if (path.thickness != nullptr) {
            auto r0 = path.thickness[0];
            auto r1 = path.thickness[path.num_points - 1];
            cap_length = float(M_PI) * (r0 + r1);
        } else {
            cap_length = 2 * float(M_PI) * stroke_radius;
        }
        auto cap_prob = cap_length / (cap_length + path_length);
        if (t < cap_prob) {
            t = t / cap_prob;
            pdf *= cap_prob;
            auto r0 = stroke_radius;
            auto r1 = stroke_radius;
            if (path.thickness != nullptr) {
                r0 = path.thickness[0];
                r1 = path.thickness[path.num_points - 1];
            }
            // HACK: in theory we want to compute the tangent and
            //       sample the hemi-circle, but here we just sample the
            //       full circle since it's less typing
            if (stroke_perturb_direction < 0) {
                // Sample the cap at the beginning
                auto p0 = Vector2f{path.points[0], path.points[1]};
                auto offset = Vector2f{
                    r0 * cos(2 * float(M_PI) * t),
                    r0 * sin(2 * float(M_PI) * t)
                };
                normal = normalize(offset);
                pdf /= (2 * float(M_PI) * r0);
                data.path.base_point_id = 0;
                data.path.point_id = 0;
                data.path.t = 0;
                return p0 + offset;
            } else {
                // Sample the cap at the end
                auto p0 = Vector2f{path.points[2 * (path.num_points - 1)],
                                   path.points[2 * (path.num_points - 1) + 1]};
                auto offset = Vector2f{
                    r1 * cos(2 * float(M_PI) * t),
                    r1 * sin(2 * float(M_PI) * t)
                };
                normal = normalize(offset);
                pdf /= (2 * float(M_PI) * r1);
                data.path.base_point_id = path.num_base_points - 1;
                data.path.point_id = path.num_points - 2 - 
                                     path.num_control_points[data.path.base_point_id];
                data.path.t = 1;
                return p0 + offset;
            }
        } else {
            t = (t - cap_prob) / (1 - cap_prob);
            pdf *= (1 - cap_prob);
        }
    }
    // Binary search on path_length_cdf
    auto sample_id = sample(path_length_cdf,
                            path.num_base_points,
                            t,
                            &t);
    assert(sample_id >= 0 && sample_id < path.num_base_points);
    auto point_id = point_id_map[sample_id];
    if (path.num_control_points[sample_id] == 0) {
        // Straight line
        auto i0 = point_id;
        auto i1 = (i0 + 1) % path.num_points;
        assert(i0 < path.num_points);
        auto p0 = Vector2f{path.points[2 * i0], path.points[2 * i0 + 1]};
        auto p1 = Vector2f{path.points[2 * i1], path.points[2 * i1 + 1]};
        data.path.base_point_id = sample_id;
        data.path.point_id = point_id;
        data.path.t = t;
        if (t < -1e-3f || t > 1+1e-3f) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        auto tangent = (p1 - p0);
        auto tan_len = length(tangent);
        if (tan_len == 0) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        normal = Vector2f{-tangent.y, tangent.x} / tan_len;
        // length of tangent is the Jacobian of the sampling transformation
        pdf *= path_length_pmf[sample_id] / tan_len;
        auto ret = p0 + t * (p1 - p0);
        if (stroke_perturb_direction != 0.f) {
            auto r0 = stroke_radius;
            auto r1 = stroke_radius;
            if (path.thickness != nullptr) {
                r0 = path.thickness[i0];
                r1 = path.thickness[i1];
            }
            auto r = r0 + t * (r1 - r0);
            ret += stroke_perturb_direction * r * normal;
            if (stroke_perturb_direction < 0) {
                // normal should point towards the perturb direction
                normal = -normal;
            }
        }
        return ret;
    } else if (path.num_control_points[sample_id] == 1) {
        // Quadratic Bezier curve
        auto i0 = point_id;
        auto i1 = i0 + 1;
        auto i2 = (i0 + 2) % path.num_points;
        auto p0 = Vector2f{path.points[2 * i0], path.points[2 * i0 + 1]};
        auto p1 = Vector2f{path.points[2 * i1], path.points[2 * i1 + 1]};
        auto p2 = Vector2f{path.points[2 * i2], path.points[2 * i2 + 1]};
        auto eval = [&](float t) -> Vector2f {
            auto tt = 1 - t;
            return (tt*tt)*p0 + (2*tt*t)*p1 + (t*t)*p2;
        };
        data.path.base_point_id = sample_id;
        data.path.point_id = point_id;
        data.path.t = t;
        if (t < -1e-3f || t > 1+1e-3f) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        auto tangent = 2 * (1 - t) * (p1 - p0) + 2 * t * (p2 - p1);
        auto tan_len = length(tangent);
        if (tan_len == 0) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        normal = Vector2f{-tangent.y, tangent.x} / tan_len;
        // length of tangent is the Jacobian of the sampling transformation
        pdf *= path_length_pmf[sample_id] / tan_len;
        auto ret = eval(t);
        if (stroke_perturb_direction != 0.f) {
            auto r0 = stroke_radius;
            auto r1 = stroke_radius;
            auto r2 = stroke_radius;
            if (path.thickness != nullptr) {
                r0 = path.thickness[i0];
                r1 = path.thickness[i1];
                r2 = path.thickness[i2];
            }
            auto tt = 1 - t;
            auto r = (tt*tt)*r0 + (2*tt*t)*r1 + (t*t)*r2;
            ret += stroke_perturb_direction * r * normal;
            if (stroke_perturb_direction < 0) {
                // normal should point towards the perturb direction
                normal = -normal;
            }
        }
        return ret;
    } else if (path.num_control_points[sample_id] == 2) {
        // Cubic Bezier curve
        auto i0 = point_id;
        auto i1 = point_id + 1;
        auto i2 = point_id + 2;
        auto i3 = (point_id + 3) % path.num_points;
        assert(i0 >= 0 && i2 < path.num_points);
        auto p0 = Vector2f{path.points[2 * i0], path.points[2 * i0 + 1]};
        auto p1 = Vector2f{path.points[2 * i1], path.points[2 * i1 + 1]};
        auto p2 = Vector2f{path.points[2 * i2], path.points[2 * i2 + 1]};
        auto p3 = Vector2f{path.points[2 * i3], path.points[2 * i3 + 1]};
        auto eval = [&](float t) -> Vector2f {
            auto tt = 1 - t;
            return (tt*tt*tt)*p0 + (3*tt*tt*t)*p1 + (3*tt*t*t)*p2 + (t*t*t)*p3;
        };
        data.path.base_point_id = sample_id;
        data.path.point_id = point_id;
        data.path.t = t;
        if (t < -1e-3f || t > 1+1e-3f) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        auto tangent = 3 * square(1 - t) * (p1 - p0) + 6 * (1 - t) * t * (p2 - p1) + 3 * t * t * (p3 - p2);
        auto tan_len = length(tangent);
        if (tan_len == 0) {
            // return invalid sample
            pdf = 0;
            return Vector2f{0, 0};
        }
        normal = Vector2f{-tangent.y, tangent.x} / tan_len;
        // length of tangent is the Jacobian of the sampling transformation
        pdf *= path_length_pmf[sample_id] / tan_len;
        auto ret = eval(t);
        if (stroke_perturb_direction != 0.f) {
            auto r0 = stroke_radius;
            auto r1 = stroke_radius;
            auto r2 = stroke_radius;
            auto r3 = stroke_radius;
            if (path.thickness != nullptr) {
                r0 = path.thickness[i0];
                r1 = path.thickness[i1];
                r2 = path.thickness[i2];
                r3 = path.thickness[i3];
            }
            auto tt = 1 - t;
            auto r = (tt*tt*tt)*r0 + (3*tt*tt*t)*r1 + (3*tt*t*t)*r2 + (t*t*t)*r3;
            ret += stroke_perturb_direction * r * normal;
            if (stroke_perturb_direction < 0) {
                // normal should point towards the perturb direction
                normal = -normal;
            }
        }
        return ret;
    } else {
        assert(false);
    }
    assert(false);
    return Vector2f{0, 0};
}

DEVICE
Vector2f sample_boundary(const Rect &rect,
                         float t, Vector2f &normal,
                         float &pdf,
                         BoundaryData &,
                         float stroke_perturb_direction,
                         float stroke_radius) {
    // Roll a dice to decide whether to sample width or height
    auto w = rect.p_max.x - rect.p_min.x;
    auto h = rect.p_max.y - rect.p_min.y;
    pdf /= (2 * (w +h));
    if (t <= w / (w + h)) {
        // Sample width
        // reuse t for the next dice
        t *= (w + h) / w;
        // Roll a dice to decide whether to sample upper width or lower width
        if (t < 0.5f) {
            // Sample upper width
            normal = Vector2f{0, -1};
            auto ret = rect.p_min + 2 * t * Vector2f{rect.p_max.x - rect.p_min.x, 0.f};
            if (stroke_perturb_direction != 0.f) {
                ret += stroke_perturb_direction * stroke_radius * normal;
                if (stroke_perturb_direction < 0) {
                    // normal should point towards the perturb direction
                    normal = -normal;
                }
            }
            return ret;
        } else {
            // Sample lower width
            normal = Vector2f{0, 1};
            auto ret = Vector2f{rect.p_min.x, rect.p_max.y} +
                2 * (t - 0.5f) * Vector2f{rect.p_max.x - rect.p_min.x, 0.f};
            if (stroke_perturb_direction != 0.f) {
                ret += stroke_perturb_direction * stroke_radius * normal;
                if (stroke_perturb_direction < 0) {
                    // normal should point towards the perturb direction
                    normal = -normal;
                }
            }
            return ret;
        }
    } else {
        // Sample height
        // reuse t for the next dice
        assert(h > 0);
        t = (t - w / (w + h)) * (w + h) / h;
        // Roll a dice to decide whether to sample left height or right height
        if (t < 0.5f) {
            // Sample left height
            normal = Vector2f{-1, 0};
            auto ret = rect.p_min + 2 * t * Vector2f{0.f, rect.p_max.y - rect.p_min.y};
            if (stroke_perturb_direction != 0.f) {
                ret += stroke_perturb_direction * stroke_radius * normal;
                if (stroke_perturb_direction < 0) {
                    // normal should point towards the perturb direction
                    normal = -normal;
                }
            }
            return ret;
        } else {
            // Sample right height
            normal = Vector2f{1, 0};
            auto ret = Vector2f{rect.p_max.x, rect.p_min.y} +
                2 * (t - 0.5f) * Vector2f{0.f, rect.p_max.y - rect.p_min.y};
            if (stroke_perturb_direction != 0.f) {
                ret += stroke_perturb_direction * stroke_radius * normal;
                if (stroke_perturb_direction < 0) {
                    // normal should point towards the perturb direction
                    normal = -normal;
                }
            }
            return ret;
        }
    }
}

DEVICE
Vector2f sample_boundary(const SceneData &scene,
                         int shape_group_id,
                         int shape_id,
                         float t,
                         Vector2f &normal,
                         float &pdf,
                         BoundaryData &data) {
    const ShapeGroup &shape_group = scene.shape_groups[shape_group_id];
    const Shape &shape = scene.shapes[shape_id];
    pdf = 1;
    // Choose which one to sample: stroke discontinuities or fill discontinuities.
    // TODO: we don't need to sample fill discontinuities when stroke alpha is 1 and both
    // fill and stroke color exists
    auto stroke_perturb = false;
    if (shape_group.fill_color != nullptr && shape_group.stroke_color != nullptr) {
        if (t < 0.5f) {
            stroke_perturb = false;
            t = 2 * t;
            pdf = 0.5f;
        } else {
            stroke_perturb = true;
            t = 2 * (t - 0.5f);
            pdf = 0.5f;
        }
    } else if (shape_group.stroke_color != nullptr) {
        stroke_perturb = true;
    }
    data.is_stroke = stroke_perturb;
    auto stroke_perturb_direction = 0.f;
    if (stroke_perturb) {
        if (t < 0.5f) {
            stroke_perturb_direction = -1.f;
            t = 2 * t;
            pdf *= 0.5f;
        } else {
            stroke_perturb_direction = 1.f;
            t = 2 * (t - 0.5f);
            pdf *= 0.5f;
        }
    }
    switch (shape.type) {
        case ShapeType::Circle:
            return sample_boundary(
                *(const Circle *)shape.ptr, t, normal, pdf, data, stroke_perturb_direction, shape.stroke_width);
        case ShapeType::Ellipse:
            return sample_boundary(
                *(const Ellipse *)shape.ptr, t, normal, pdf, data, stroke_perturb_direction, shape.stroke_width);
        case ShapeType::Path:
            return sample_boundary(
                *(const Path *)shape.ptr,
                scene.path_length_cdf[shape_id],
                scene.path_length_pmf[shape_id],
                scene.path_point_id_map[shape_id],
                scene.shapes_length[shape_id],
                t,
                normal,
                pdf,
                data,
                stroke_perturb_direction,
                shape.stroke_width);
        case ShapeType::Rect:
            return sample_boundary(
                *(const Rect *)shape.ptr, t, normal, pdf, data, stroke_perturb_direction, shape.stroke_width);
    }
    assert(false);
    return Vector2f{};
}