constraint_solver.h

浏览该文件的文档.

#pragma once
#include "vde/core/point.h"
#include <vector>
#include <string>
#include <unordered_map>
 
namespace vde::sketch {
using core::Point2D;
using core::Vector2D;
 
struct SketchPoint {
    int id;            
    Point2D pos;       
    bool fixed = false; 
};
 
struct SketchLine {
    int id;            
    int p0, p1;        
};
 
struct SketchCircle {
    int id;            
    int center;        
    double radius;     
};
 
enum class ConstraintType {
    Horizontal,     
    Vertical,       
    Parallel,       
    Perpendicular,  
    Coincident,     
    EqualLength,    
    Distance,       
    Radius,         
    Tangent,        
    Concentric,     
    FixedPoint,     
    Fixed,          
    Angle,          
};
 
struct Constraint {
    ConstraintType type;              
    std::vector<int> elements;        
    double value = 0.0;               
};
 
struct SolverResult {
    bool converged = false;           
    int iterations = 0;               
    double residual = 0.0;            
    std::vector<Point2D> points;      
    std::string message;              
};
 
class ConstraintSolver {
public:
    int add_point(double x, double y, bool fixed = false);
 
    int add_line(int p0, int p1);
 
    int add_circle(int center, double radius);
 
    void add_constraint(ConstraintType type, const std::vector<int>& elements, double val = 0.0);
 
    void fix_point(int pid) {
        if (pid >= 0 && pid < static_cast<int>(points_.size()))
            points_[pid].fixed = true;
    }
 
    [[nodiscard]] SolverResult solve(int max_iter = 100, double tol = 1e-8);
 
    [[nodiscard]] int degrees_of_freedom() const;
 
    [[nodiscard]] const std::vector<SketchPoint>& points() const { return points_; }
 
    [[nodiscard]] Point2D get_point(int id) const;
 
private:
    std::vector<SketchPoint> points_;       
    std::vector<SketchLine> lines_;         
    std::vector<SketchCircle> circles_;     
    std::vector<Constraint> constraints_;   
 
    void sync_from_vars(const double* vars, int nv);
 
    double eval_constraint(const Constraint& c) const;
 
    int count_equations(const Constraint& c) const;
 
    void fill_jacobian_rows(const Constraint& c, int ci,
                            const std::vector<int>& row_map,
                            double* J_data, int nv, int stride) const;
};
 
}  // namespace vde::sketch