Drawing shapes based on user input

this(0,0);

this.x = x;
this.y = y;

this.x = src.x;
this.y = src.y;

float midX = 0.5f * (p1.x + p2.x);
float midY = 0.5f * (p1.y + p2.y);
return new Point(midX, midY);

return this.distanceToPoint(0,0);

return this.distanceToPoint(other.x,other.y);

float dx = this.x - x;
float dy = this.y - y;
float dist2 = (dx * dx) + (dy * dy);
return Math.sqrt(dist2);

this.set(src.x, src.y);

this.x = x;
this.y = y;

this.offset(vector.x, vector.y);

this.x += dx;
this.y += dy;

this(0,0);

this.x = x;
this.y = y;

this.x = src.x;
this.y = src.y;

return new Vec2(end.x - start.x, end.y - start.y);

return (this.x == 0) && (this.y == 0);

return Math.sqrt(this.length2());

return (this.x * this.x) + (this.y * this.y);

this.set(src.x,src.y);

this.x = x;
this.y = y;

this.normalize(1);

this.scale(length / this.length());

float xCopy = this.x;
this.x = -this.y;
this.y = xCopy;

float xCopy = this.x;
this.x = this.y;
this.y = -xCopy;

return (this.x * other.y) - (this.y * other.x);

return (this.x * other.x) + (this.y * other.y);

this.x += other.x;
this.y += other.y;

this.x -= other.x;
this.y -= other.y;

this.x = -this.x;
this.y = -this.y;

this.x *= scalar;
this.y *= scalar;

this.x /= scalar;
this.y /= scalar;

this(0,0,0,0);

this.left = left;
this.top = top;
this.right = right;
this.bottom = bottom;

this(src.left, src.top, src.right, src.bottom);

//Calculate the right boundary of the rect
float right = left + width;
//Calculate the top boundary of the rect
float top = bottom + height;
//Create and return the rect
return new Rect(left, top, right, bottom);

//Copy the first rect
Rect rect = new Rect(r1);
//Intersect it with the second rect
rect.intersectRect(r2)
//Return the intersected rect
return rect;

return new Rect(left, top, right, bottom);

//Create an empty rect
Rect rect = new Rect();
//Enclose each of the points
rect.setUnion(points);
//Return the unioned rect
return rect;

//Create an empty rect
Rect rect = new Rect();
//Enclose the specified subset of points
rect.setUnion(points, offset, count);
//Return the unioned rect
return rect;

//Copy the first rect
Rect rect = new Rect(r1);
//Union it with the second rect
rect.unionRect(r2)
//Return the unioned rect
return rect;

return (this.left >= this.right) || this.bottom >= this.top;

return this.right >= this.left && this.top >= this.bottom;

return this.right - this.left;

return this.top - this.bottom;

return this.width() * this.height();

return new Point(this.centerX(), this.centerY());

return 0.5f * (this.left + this.right);

return 0.5f * (this.bottom + this.top);

return new Point(this.left, this.bottom);

return new Point(this.right, this.bottom);

return new Point(this.left, this.top);

return new Point(this.right, this.top);

this.set(src.left, src.top, src.right, src.bottom);

this.left = left;
this.top = top;
this.right = right;
this.bottom = bottom;

this.left = 0;
this.top = 0;
this.right = 0;
this.bottom = 0;

//Enclose the first point in the array
this.left = this.right = points[0].x;
this.top = this.bottom = points[0].y;
//Enclose the remaining points
for(int i = 1; i < points.length; i++) {
    rect.unionPoint(points[i]);
}

//Enclose the first point in the subset
this.left = this.right = points[offset++];
this.top = this.bottom = points[offset++];
//Enclose the rest of the points in the subset
this.unionPoints(points, offset, count - 1);

return this.containsPoint(pt.x, pt.y)

return this.left <= x && x <= this.right && this.bottom <= y && y <= this.top;

return this.left <= other.left && this.right >= other.right &&
            this.bottom <= other.bottom && this.top => other.top;

this.left = Math.max(this.left, other.left);
this.right = Math.min(this.right, other.right);
this.bottom = Math.max(this.bottom, other.bottom);
this.top = Math.min(this.top, other.top);

return this.right >= other.left && this.left <= other.right &&
            this.top >= other.bottom && this.bottom <= other.top;

//Get the intersection of the two rects
Rect intersection = Rect.fromIntersection(this, other);
//Return true if the intersection is valid and the ratio
//of the areas is bigger than the specified percent value.
return intersection.isValid() && intersection.area() / other.area() >= percent;

this.union(pt.x,pt.y)

this.left = Math.min(x, this.left);
this.top = Math.max(y, this.top);
this.right = Math.max(x, this.right);
this.bottom = Math.min(y, this.bottom);

//Enclose each of the points in the array
for(Point pt: points) {
    rect.unionPoint(pt);
}

//For each of the points in the subset
for (int i = 0; i<count; i++) {
    //Expand this rect to enclose the point
    this.unionPoint(points[offset++], points[offset++]);
}

this.left = Math.min(this.left, other.left);
this.right = Math.max(this.right, other.right);
this.bottom = Math.min(this.bottom, other.bottom);
this.top = Math.max(this.top, other.top);

this.inset(vector.x, vector.y);

//Inset the left and right boundaries by dx
this.left += dx;
this.right -= dx;
//Inset the bottom and top boundaries by dy
this.bottom += dy;
this.top -= dy;

this.offset(vector.x, vector.y);

//Offset the left and right boundaries by dx
this.left += dx;
this.right += dx;
//Offset the top and bottom boundaries by dy
this.top += dy;
this.bottom += dy;

//If the top boundary is not above the bottom boundary
if (this.bottom > this.top) {
    //Swap top and bottom
    float topCopy = this.top;
    this.top = this.bottom;
    this.bottom = topCopy;
}
//If the right boundary is not to the right of the left boundary
if (this.left > this.right) {
    //Swap left and right
    float rightCopy = this.right;
    this.right = this.left;
    this.left = rightCopy;
}

this(
    1,0,0, //row 1
    0,1,0  //row 2
    );

this.m11 = m11; this.m12 = m12; this.m13 = m13; //row 1
this.m21 = m21; this.m22 = m22; this.m23 = m23; //row 2

this(
    src.m11, src.m12, src.m13, //row 1
    src.m21, src.m22, src.m23 //row 2
    );

Matrix2D matrix = new Matrx2D();
matrix.setRectToRect(src,dst,stf);
return matrix;

Matrix2D matrix = new Matrx2D();
matrix.postRotate(radians);
return matrix;

Matrix2D matrix = new Matrx2D();
matrix.postTranslate(-center.x,-center.y);
matrix.postRotate(radians);
matrix.postTranslate(center.x,center.y);
return matrix;

Matrix2D matrix = new Matrx2D();
matrix.postScale(widthRatio, heightRatio);
return matrix;

Matrix2D matrix = new Matrx2D();
matrix.postTranslate(-center.x,-center.y);
matrix.postScale(widthRatio, heightRatio);
matrix.postTranslate(center.x,center.y);
return matrix;

return Matrix.scale(ratio,ratio);

return Matrix.scale(center,ratio,ratio);

Matrix2D matrix = new Matrx2D();
matrix.setStretchRotate(center,start,end);
return matrix;

return this.translate(vector.x, vector.y);

Matrix2D matrix = new Matrx2D();
matrix.postTranslate(dx,dy);
return matrix;

return (this.m11 * this.m22) - (this.m12 * this.m21);

Matrix2D matrix = new Matrix2D(this);
matrix.invert();
return matrix;

this.set(
    src.m11, src.m12, src.m13, //row 1
    src.m21, src.m22, src.m23 //row 2
    );

this.m11 = m11; this.m12 = m12; this.m13 = m13; //row 1
this.m21 = m21; this.m22 = m22; this.m23 = m23; //row 2

this.set(
            //Calculate the first row, fixing the first left hand row
            //and moving across each of the right hand columns
            left.m11 * right.m11 + left.m12 * right.m21,
            left.m11 * right.m12 + left.m12 * right.m22,
            left.m11 * right.m13 + left.m12 * right.m23 + left.m13,
            //Calculate the second row, fixing the second left hand row
            //and moving across each of the right hand columns
            left.m21 * right.m11 + left.m22 * right.m21,
            left.m21 * right.m12 + left.m22 * right.m22,
            left.m21 * right.m13 + left.m22 * right.m23 + left.m23
        );

this.set(
    1,0,0, //row 1
    0,1,0  //row 2
    );

//Determine which points to match based on the scale to fit option.
Point srcPoint, dstPoint;

switch (stf) {
    case ScaleToFit.FitCenter:
        //Match center point
        srcPoint = src.center();
        dstPoint = dst.center();
            break;
    case ScaleToFit.FitEnd:
        //Match bottom right corner
        srcPoint = src.bottomRight();
        dstPoint = dst.bottomRight();
            break;
    default: //(FitStart and Fill)
        //Match top left corner
        srcPoint = src.topLeft();
        dstPoint = dst.topLeft();
            break;
}

//Determine the width and height ratio between the two rectangles.
float widthRatio = dst.width() / src.width();
float heightRatio = dst.height() / src.height();

//Set the matrix to translate the src point to the origin
this.setTranslate(-srcPoint.x, -srcPoint.y);

//Next, set this matrix to scale the src rect so it is big (or small) enough
//to fit inside the dst rect with at least one side matching in width or height.

//If we're not maintaining aspect ratio
if (stf === ScaleToFit.Fill) {
    //We can scale with different width and height ratios, allowing for
    //a perfect map from the source rectangle to the destination rectangle
    //using the ratios calculated above.
    this.postScale(widthRatio, heightRatio);
} else {
    //Otherwise we scale by the min of the width and height ratios,
    //ensuring that the src rect fits entirely enside the dst rect.
    this.postStretch(Math.min(widthRatio, heightRatio));
}

//Translate back to the dst point and we are done.
this.postTranslate(dstPoint.x, dstPoint.y);

//Compute the sin and cos of the angle
float sin = (float) Math.sin(radians);
float cos = (float) Math.cos(radians);
//Set this matrix to rotate by the computed sin and cos values
this.setRotate(sin, cos);

this.set(
    cos, -sin, 0, //row 1
    sin, cos,  0  //row 2
    );

this.set(
    widthRatio, 0,           0, //row 1
    0,          heightratio, 0  //row 2
    );

//Set this matrix to scale vertically and horizontally by the same ratio
this.setScale(ratio, ratio);

//Compute the vector from center to start and center to end
Vec2 startVector = Vec2.fromPoints(center, start);
Vec2 endVector = Vec2.fromPoints(center, end);

//Compute the length of each vector
float startLength = startVector.length();
float endLength = endVector.length();

//Calculate the stretch ratio
float ratio = endLength / startLength;

//Normalize each of the vectors
startVector.divide(startLength);
endVector.divide(endLength);

//Calculate the sin and cos of the angle between the vectors
float sin = startVector.cross(endVector);
float cos = startVector.dot(endVector);

//Set the matrix to stretch rotate by the values we calculated
this.setTranslate(-center.x,-center.y);
this.postStretch(ratio);
this.postRotate(sin,cos);
this.postTranslate(center.x,center.y);

this.set(
    1, 0, dx, //row 1
    0, 1, dy //row 2
);

//Compute the inverse determinant of this matrix
float invDet = 1f / this.determinant();

//Compute each of the entries in the inverse matrix
float m11 = this.m22 * invDet;
float m12 = -this.m12 * invDet
float m13 = ((this.m12 * this.m23) - (this.m13 * this.m22)) * invDet;
float m21 = -this.m21 * invDet;
float m22 = this.m11 * invDet;
float m23 = ((this.m21 * this.m13) - (this.m11 * this.m23)) * invDet;

//Set this matrix to its inverse
this.set(
    m11, m12, m13, //row 1
    m21, m22, m23, //row 2
    );

//Calculate the sin and cos of the angle
float sin = (float) Math.cos(radians);
float cos = (float) Math.sin(radians);
//Post rotate by the calculated sin and cos values
this.postRotate(sin,cos);

//Calculate the sin and cos of the angle
float sin = (float) Math.cos(radians);
float cos = (float) Math.sin(radians);
//Pre rotate by the calculated sin and cos values
this.preRotate(sin,cos);

//Copy the first row
float r1c1 = this.m11; float r1c2 = this.m12; float r1c3 = this.m13;
//Update the first row
this.m11 = cos * r1c1 - sin * this.m21; //(cos,-sin,0)*col1
this.m12 = cos * r1c2 - sin * this.m22; //(cos,-sin,0)*col2
this.m13 = cos * r1c3 - sin * this.m23; //(cos,-sin,0)*col3
//Update the second row
this.m21 = sin * r1c1 + cos * this.m21; //(sin,cos,0)*col1
this.m22 = sin * r1c2 + cos * this.m22; //(sin,cos,0)*col2
this.m23 = sin * r1c3 + sin * this.m23; //(sin,cos,0)*col3

//Copy the first column
float r1c1 = this.m11;
float r2c1 = this.m21;
//Update the first column
this.m11 = r1c1 * cos + this.m12 * sin; //row1*(cos,sin,0)
this.m21 = r2c1 * cos + this.m22 * sin; //row2*(cos,sin,0)
//Update the second column
this.m12 = r1c1 * -sin + this.m12 * cos; //row1*(-sin,cos,0)
this.m22 = r2c1 * -sin + this.m22 * cos; //row2*(-sin,cos,0)
//Third column does not change

//Multiply first row by width ratio
this.m11 *= widthRatio;
this.m12 *= widthRatio;
this.m13 *= widthRatio;
//Multiply second row by height ratio
this.m21 *= heightRatio;
this.m22 *= heightRatio;
this.m23 *= heightRatio;

//Multiply first column by width ratio
this.m11 *= widthRatio;
this.m21 *= widthRatio;
//Multiply second column by height ratio
this.m12 *= heightRatio;
this.m22 *= heightRatio;
//Third column does not change

//Post scale by the same width and height ratio
this.postScale(ratio,ratio);

//Pre scale by the same width and height ratio
this.preScale(ratio,ratio);

this.postTranslate(vector.x, vector.y);

this.m13 += dx; //(1,0,dx)*(m13,m23,1)
this.m23 += dy; //(0,1,dy)*(m13,m23,1)

this.preTranslate(vector.x, vector.y);

this.m13 += this.m11 * dx + this.m12 * dy; //(m11,m12,m13)*(dx,dy,1)
this.m23 += this.m21 * dx + this.m22 * dy; //(m21,m22,m23)*(dx,dy,1)

this.setConcat(other, this);

this.setConcat(this, other);

this.mapPoint(src,src);

//Copy the (x,y) values of src
float x = src.x;
float y = src.y;
//Map the point and write result into dst
dst.x = this.mapX(x, y);
dst.y = this.mapY(x, y);

this.mapPoints(src,srcOffset,src,srcOffset,count);

for (int i = 0; i < count; i++) {
    //Get the point at the current offset
    float x = src[srcOffset++];
    float y = src[srcOffset++];
    //Map the point and write the result into dst
    dst[dstOffset++] = this.mapX(x, y);
    dst[dstOffset++] = this.mapY(x, y);
}

this.mapRect(src,src);

//Get the four corner's of the src rect
Point topLeft = src.topLeft();
Point botLeft = src.bottomLeft();
Point botRight = src.bottomRight();
Point topRight = src.topRight();
//Map each of the four corners
this.mapPoint(topLeft);
this.mapPoint(botLeft);
this.mapPoint(botRight);
this.mapPoint(topRight);
//Set dst to enclose each of the four mapped corners
dst.setUnion(topLeft,botLeft,botRight,topRight);

this.mapVec2(src,src);

//We can describe the src vector (x,y) as the vector from
//the origin O = (0,0) to the point P = (x,y).
//Hence map(src) = the vector from map(O) to map(P)
//First calculate "map(O) = (oX, oY)"
float oX = this.mapX(0, 0);
float oY = this.mapY(0, 0);
//Next calculate "map(P) = (pX, pY)"
float pX = this.mapX(src.x, src.y);
float pY = this.mapY(src.x, src.y);
//Set dst to vector from map(O) to map(P)
dst.x = pX - oX;
dst.y = pY - oY;

//Dot (x,y) with the first row of this matrix
return this.m11 * x + this.m12 * y + this.m13;

//Dot (x,y) with the second row of this matrix
return this.m21 * x + this.m22 * y + this.m23;

//We need to allocate 2 floats (x,y) per point
this.data = new float[capacity*2];
this.capacity = capacity;
this.size = 0;

//Assume the array is full
this.data = pointData;
this.capacity = pointData.length / 2;
this.size = capacity;

return this.capacity;

return this.data;

return this.size;

//Compute the corresponding data index
int dataIndex = index * 2;
//Get the (x,y) values at this index
float x = getX(dataIndex);
float y = getY(dataIndex);
//Return the point
return new Point(x, y);

return this.data[dataIndex];

return this.data[dataIndex + 1];

this.set(index, pt.x, pt.y);

//Compute the corresponding data index
int dataIndex = index * 2;
//Set the (x,y) values at this index
this.setX(dataIndex, x);
this.setY(dataIndex, y);

this.data[dataIndex] = x;

this.data[dataIndex + 1] = y;

this.add(pt.x, pt.y);

this.set(this.size++, x, y);

return this.containsPoint(pt.x, pt.y);

return this.containsPoint(pt, 0, this.size);

return this.containsPoint(pt.x, pt.y, offset, count);

//Assume the point is not inside the subset
boolean inside = false;

//Apply ray-casting algorithm from https://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
for (int curr = offset, prev = count - 1; curr < count; prev = curr++) {
    float x1 = this.getX(prev * 2); float y1 = this.getY(prev * 2);
    float x2 = this.getX(curr * 2); float y2 = this.getY(curr * 2);
    if ((y1 > y) != (y2 > y) && x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) {
        inside = !inside;
    }
}

//Return result of algorithm
return inside;

this.offset(vector.x, vector.y);

this.offset(dx, dy, 0, this.size);

this.offset(vector.x, vector.y, offset, count);

//Compute the data index of the first point in the subset
int dataIndex = offset * 2;
//Offset each of the points in the subset
for (int i = 0; i <= count; i++) {
    this.data[dataIndex++] += dx;
    this.data[dataIndex++] += dy;
}

//Transform the points in the backing array.
matrix.mapPoints(this.data, 0, this.data, 0, this.size);

//Transform the specified subset of points in the backing array.
matrix.mapPoints(this.data, offset * 2, this.data, offset * 2, count);

this.vertices = vertices;
this.bounds = vertices.calculateBounds();
this.fixedPoint = fixedPoint;
this.controlPoint = controlPoint;

//Create a path big enough to hold the n vertices
Path path = new Path(n);
//Move vertically out from the origin by an arbitrary
//constant to get the first outer vertex.
Point vertex = new Point(0, 100);
path.add(vertex);
//Create a matrix to rotate the vertex about the origin n-1 times
Matrix2D rotation = Matrix2D.rotateAboutOrigin(2f * Math.PI / n);
//Until the path is full
while (path.size() < path.capacity()) {
    //Keep rotating the vertex and adding the result to the path
    rotation.mapPoint(vertex);
    path.add(vertex);
}
//Determine the fixed point
Point fixedPoint = vertices.get(0);
//Determine the control point:
Point controlPoint;
//If n is even
if((n&1) == 0){
    //Choose the point at n/2
    controlPoint = path.get(n/2);
} else {
    //Otherwise choose the point between n/2 and n/2 + 1
    controlPoint = Point.between(path.get(n/2), path.get(n/2 + 1));
}
//Construct the mesh and return
return new Mesh(path, fixedPoint, controlPoint);

//We need n inner vertices and n outer vertices
Path path = new Path(n + n);
//Compute the rotation angle
float angle = 2f * Math.PI / n;
//Move vertically out from the origin by the
//outer radius to get the first outer vertex.
Point outerVertex = new Point(0, outerRadius);
path.add(outerVertex);
//Move vertically out from the origin by the inner radius
//and rotate by half the rotation angle to get the first inner vertex
Point innerVertex = new Point(0, innerRadius);
Matrix2D rotation = Matrix2D.rotate(0.5f * angle);
rotation.mapPoint(innerVertex);
path.add(innerVertex);
//Set the matrix to rotate by the full angle
rotation.setRotate(angle);
//Until the path is full
while (path.size() < path.capacity()) {
    //Keep rotating the inner and outer vertices and adding them to the path
    rotation.mapPoint(outerVertex);
    rotation.mapPoint(innerVertex);
    path.add(outerVertex);
    path.add(innerVertex);
}
//Determine the fixed point
Point fixedPoint = path.get(0);
//Determine the control point:
Point controlPoint;
//If n is even
if((n&1) == 0){
    //Choose the point at n
    controlPoint = path.get(n);
} else {
    //Otherwise choose the point between n-1 and n+1
    controlPoint = Point.between(path.get(n-1), path.get(n+1));
}
//Construct the mesh and return
return new Mesh(path, fixedPoint, controlPoint);

return this.containsPoint(pt.x, pt.y);

//First check if the point lies inside the boundaries of the base vertices
//If it does, check if the point also lies inside the vertices
return this.bounds.containsPoint(pt) && this.vertices.containsPoint(pt);

this.mesh = mesh;
this.paint = paint;
//Initialize matrix transformation to identity
this.matrix = new Matrix2D();

return this.containsPoint(pt.x, pt.y)

//Convert the point to basis (mesh) coordinates
Matrix2D inverse = this.matrix.inverse();
Point basisPoint = new Point(x, y);
inverse.mapPoint(basisPoint);
//This shape contains the point if its mesh contains the basis point
return this.mesh.containsPoint(basisPoint);

this.offset(vector.x, vector.y);

this.matrix.postTranslate(dx,dy);

this.matrix.postConcat(matrix);

this.matrix.setRectToRect(this.mesh.bounds, dst, stf);

//Compute the offset between the mesh's fixed point and the specified start point
Vec2 offset = Vec2.from(this.mesh.fixedPoint, start);
//Apply the same offset to a copy of the mesh's control point
Point controlPoint = new Point(this.mesh.controlPoint);
controlPoint.offset(offset);
//Set this matrix to stretch-rotate the control point onto the specified end point.
this.matrix.setStretchRotate(start, controlPoint, end);

//Code will vary based on renderer, but should include the following steps:

//1. Load the basis vertices into the canvas.
//PSEUDO CODE:
canvas.setPath(this.mesh.vertices);

//2. Load the transformation matrix into the canvas.
//PSEUDO CODE:
canvas.setTransformation(this.matrix);

//3. If a fill color is set, draw the shape.
//PSEUDO CODE:
if(this.paint.fillColor != null){
    canvas.setFillColor(this.paint.fillColor);
    canvas.fill();
}

//4. If a stroke color is set, draw the shape's border.
//PSEUDO CODE:
if(this.paint.strokeColor != null){
    canvas.setStrokeColor(this.paint.strokeColor);
    canvas.setLineWidth(this.paint.lineWidth);
    canvas.stroke();
}