# Source: Circle.js

``````"use strict";
/**
* @classdesc A simple circle: center point and radius.
*
* @requires Line
* @requires Vector
* @requires VertTuple
* @requires Vertex
* @requires SVGSerializale
*
* @author   Ikaros Kappler
* @version  1.1.0
* @date     2020-05-04
* @modified 2020-05-09 Ported to typescript.
* @modified 2020-05-25 Added the vertAt and tangentAt functions.
* @mofidied 2020-09-07 Added the circleIntersection(Circle) function.
* @modified 2020-09-07 Changed the vertAt function by switching sin and cos! The old version did not return the correct vertex (by angle) accoring to the assumed circle math.
* @modified 2020-10-16 Added the containsCircle(...) function.
*
* @file Circle
* @fileoverview A simple circle class: center point and radius.
* @public
**/
Object.defineProperty(exports, "__esModule", { value: true });
var Line_1 = require("./Line");
var Vector_1 = require("./Vector");
var Vertex_1 = require("./Vertex");
var Circle = /** @class */ (function () {
/**
* Create a new circle with given center point and radius.
*
* @constructor
* @name Circle
* @param {Vertex} center - The center point of the circle.
*/
/**
* Required to generate proper CSS classes and other class related IDs.
**/
this.className = "Circle";
this.center = center;
}
;
Circle.prototype.containsCircle = function (circle) {
};
;
/**
* Calculate the distance from this circle to the given line.
*
* * If the line does not intersect this ciecle then the returned
*   value will be the minimal distance.
* * If the line goes through this circle then the returned value
*   will be max inner distance and it will be negative.
*
* @method lineDistance
* @param {Line} line - The line to measure the distance to.
* @return {number} The minimal distance from the outline of this circle to the given line.
* @instance
* @memberof Circle
*/
Circle.prototype.lineDistance = function (line) {
var closestPointOnLine = line.getClosestPoint(this.center);
};
;
/**
* Get the vertex on the this circle for the given angle.
*
* @method vertAt
* @param {number} angle - The angle (in radians) to use.
* @return {Vertex} The vertex (point) at the given angle.
* @instance
* @memberof Circle
**/
Circle.prototype.vertAt = function (angle) {
// Find the point on the circle respective the angle. Then move relative to center.
};
;
/**
* Get a tangent line of this circle for a given angle.
*
* Point a of the returned line is located on the circle, the length equals the radius.
*
* @method tangentAt
* @instance
* @param {number} angle - The angle (in radians) to use.
* @return {Line} The tangent line.
* @memberof Circle
**/
Circle.prototype.tangentAt = function (angle) {
// Construct the perpendicular of the line in point a. Then move relative to center.
return new Vector_1.Vector(pointA, new Vertex_1.Vertex(0, 0)).add(this.center).perp();
};
;
/**
* Calculate the intersection points (if exists) with the given circle.
*
* @method circleIntersection
* @instance
* @memberof Circle
* @param {Circle} circle
* @return {Line|null} The intersection points (as a line) or null if the two circles do not intersect.
**/
Circle.prototype.circleIntersection = function (circle) {
// Circles do not intersect at all?
return null;
}
// One circle is fully inside the other?
return null;
}
// Based on the C++ implementation by Robert King
//    https://stackoverflow.com/questions/3349125/circle-circle-intersection-points
// and the 'Circles and spheres' article by Paul Bourke.
//    http://paulbourke.net/geometry/circlesphere/
//
// This is the original C++ implementation:
//
// pair<Point, Point> intersections(Circle c) {
//    Point P0(x, y);
//    Point P1(c.x, c.y);
//    float d, a, h;
//    d = P0.distance(P1);
//    a = (r*r - c.r*c.r + d*d)/(2*d);
//    h = sqrt(r*r - a*a);
//    float x3, y3, x4, y4;
//    x3 = P2.x + h*(P1.y - P0.y)/d;
//    y3 = P2.y - h*(P1.x - P0.x)/d;
//    x4 = P2.x - h*(P1.y - P0.y)/d;
//    y4 = P2.y + h*(P1.x - P0.x)/d;
//    return pair<Point, Point>(Point(x3, y3), Point(x4, y4));
// }
var p0 = this.center;
var p1 = circle.center;
var d = p0.distance(p1);
var p2 = p1.clone().scale(a / d, p0);
var x3 = p2.x + h * (p1.y - p0.y) / d;
var y3 = p2.y - h * (p1.x - p0.x) / d;
var x4 = p2.x - h * (p1.y - p0.y) / d;
var y4 = p2.y + h * (p1.x - p0.x) / d;
return new Line_1.Line(new Vertex_1.Vertex(x3, y3), new Vertex_1.Vertex(x4, y4));
};
;
/**
* Create an SVG representation of this circle.
*
* @method toSVGString
* @param {object=} options - An optional set of options, like 'className'.
* @return {string} A string representing the SVG code for this vertex.
* @instance
* @memberof Circle
*/
Circle.prototype.toSVGString = function (options) {
options = options || {};
var buffer = [];
buffer.push('<circle');
if (options.className)
buffer.push(' class="' + options.className + '"');
buffer.push(' cx="' + this.center.x + '"');
buffer.push(' cy="' + this.center.y + '"');
buffer.push(' r="' + this.radius + '"');
buffer.push(' />');
return buffer.join('');
};
;
Circle.circleUtils = {