Csc2dTypes.h

Go to the documentation of this file.

//
//  Csc2dTypes.hpp
//  ConscienceRobotManager
//
//  Created by Ilies Zaoui on 29/07/2021.
//  Copyright © 2019 Conscience Robotics. All rights reserved.
//
 
#ifndef Csc2dTypes_h
#define Csc2dTypes_h
 
#include <map>
#include <string>
#include <vector>
using std::string, std::map, std::vector;
 
namespace conscience_core::axiomes {
 
class CscRect2d;
 
class CscPoint2d {
 
public:
    double x;
    double y;
 
    CscPoint2d(const CscPoint2d *fromPoint);
    CscPoint2d(double inX = 0, double inY = 0);
    virtual ~CscPoint2d() = default;
 
    // Opérateur d'affectation par copie
    CscPoint2d& operator=(const CscPoint2d& other) {
        if (this != &other) {
            x = other.x;
            y = other.y;
        }
        return *this;
    }
 
    double getX() const;
    double getY() const;
    virtual operator string() const { return toString(); }
    virtual string toString() const;
 
    double distanceWith(const CscPoint2d *point);
    double distanceWith(const CscPoint2d &point);
 
    CscPoint2d plus(const CscPoint2d &other) const;
    CscPoint2d minus(const CscPoint2d &other) const;
    CscPoint2d operator+(const CscPoint2d &other) const;
    CscPoint2d operator-(const CscPoint2d &other) const;
 
    bool isInside(const CscRect2d &rectangle) const;
 
    virtual map<string, double> toMap() const;
 
    virtual CscPoint2d *clone() const;
 
    static CscPoint2d *zero();
 
 
};
 
typedef CscPoint2d CscSize2d;
 
vector<const CscPoint2d *> clonePoints2d(const vector<const CscPoint2d *> &originalVector);
 
class CscLine2d {
 
public:
    CscLine2d(const CscPoint2d *first = CscPoint2d::zero(), const CscPoint2d *second = CscPoint2d::zero(), const string &colorHex = "#6abc8e", const int width = 1);
    ~CscLine2d();
 
    const CscPoint2d *getFirst() const;
    const CscPoint2d *getSecond() const;
    operator string() const { return toString(); }
    string toString() const;
 
 
private:
    const CscPoint2d *first;
    const CscPoint2d *second;
 
};
 
vector<CscLine2d*> cloneLines2d(const vector<CscLine2d*> &originalVector);
 
class CscLine2dStylized : public CscLine2d {
 
public:
    CscLine2dStylized(const CscPoint2d *first, const CscPoint2d *second, const string &colorHex = "#6abc8e", const int width = 1);
    ~CscLine2dStylized();
 
    const string &getColorHex() const;
    int getWidth() const;
 
private:
 
    const string colorHex; //format : #ffffff
    const int width;
};
 
vector<CscLine2dStylized*> cloneLine2dStylized(const vector<CscLine2dStylized*> &originalVector);
 
class CscRect2d {
public:
    CscPoint2d bottomLeft;
    CscSize2d size;
    CscRect2d(double bottomLeftX = 0, double bottomLeftY = 0, double width = 0, double height = 0);
    CscRect2d(const CscPoint2d &bottomLeft, const CscSize2d &size);
    CscRect2d(const CscRect2d &other);
    CscRect2d(CscRect2d &&other);
 
    // Opérateur d'affectation par copie
    CscRect2d& operator=(const CscRect2d& other) {
        if (this != &other) { // Vérifie l'auto-affectation
            bottomLeft = other.bottomLeft;
            size = other.size;
        }
        return *this;
    }
 
    // Opérateur d'affectation par déplacement
    CscRect2d& operator=(CscRect2d&& other) noexcept {
        if (this != &other) { // Vérifie l'auto-affectation
            bottomLeft = std::move(other.bottomLeft);
            size = std::move(other.size);
        }
        return *this;
    }
 
    CscPoint2d topLeft() const;
    CscPoint2d topRight() const;
    CscPoint2d bottomRight() const;
    CscPoint2d center() const;
    CscRect2d intersection(const CscRect2d &other) const;
    double area() const;
 
    double getWidth() const;
    double getHeight() const;
    bool isIncludedInOther(const CscRect2d &rectangle) const;
 
    string toString() const;
 
    double distanceWith(const CscRect2d &rectangle2) const;
    double getIntersectionOverUnionWith(const CscRect2d &bb2) const;
 
};
 
CscRect2d averageRectangle(const vector<CscRect2d> &rectangles);
 
 
class CscPoint2dOriented : public CscPoint2d {
 
public:
    double rotation;
 
    static CscPoint2dOriented *zero();
 
    CscPoint2dOriented(const CscPoint2d &point, double rotation);
    CscPoint2dOriented(double x = 0, double y = 0, double rotation = 0);
    ~CscPoint2dOriented() override = default;
 
    double getRotation() const;
 
    void setRotation(double rotation);
 
    CscPoint2dOriented *clone() const override;
 
    map<string, double> toMap() const override;
    string toString() const override;
};
 
}
#endif /* Csc2dTypes_h */