public List <QDShapeDBPoint> getShapesNearPoint(QDPoint point, float radius) { // Get the ShapeSampledPoints near the query point List <QDPoint> pts = new List <QDPoint>(); quadTree.getPoints(point, radius, pts); // Create a list of all the PointSets this corresponds to //HashMap<QDInputPointSet, HashSet<PointTypes>> returnPtSets = new HashMap<>(); List <QDShapeDBPoint> returnPts = new List <QDShapeDBPoint>(); foreach (QDPoint pt in pts) { returnPts.Add((QDShapeDBPoint)pt); // QDInputPointSet ptSet = ptSets.get( ((ShapeSampledPoint)pt).objectID ); // HashSet<PointTypes> types = new HashSet<>(); // // check to see if the list already contains the PointSet // if (returnPtSets.containsKey(ptSet)){ // types = returnPtSets.get(ptSet); // types.add(((SampledPoint) pt).type); // } // else { // types.add(((SampledPoint) pt).type); // // } // returnPtSets.put(ptSet, types); } return(returnPts); }
public void addPoint(QDPoint pt) { // If the current master node does not contain the point, keep increasing the square size until it does while (!masterNode.contains(pt)) { bool expandXPos = true; // Whether the quad tree should expand in positive or negative direction bool expandYPos = true; float newCnrX, newCnrY; // Check where new point is located relative to current master node if (pt.x > masterNode.maxX) { expandXPos = true; newCnrX = masterNode.minX; } else { expandXPos = false; newCnrX = masterNode.minX - masterNode.width; } if (pt.y > masterNode.maxY) { expandYPos = true; newCnrY = masterNode.minY; } else { expandYPos = false; newCnrY = masterNode.minY - masterNode.height; } // Initialise new master node QuadNode newMaster = new QuadNode(newCnrX, newCnrY, masterNode.size * 2f); newMaster.topL = new QuadNode(newCnrX, newCnrY, masterNode.size); newMaster.topR = new QuadNode(newCnrX + masterNode.size, newCnrY, masterNode.size); newMaster.botL = new QuadNode(newCnrX, newCnrY + masterNode.size, masterNode.size); newMaster.botR = new QuadNode(newCnrX + masterNode.size, newCnrY + masterNode.size, masterNode.size); // Insert current master node into newMaster if (expandXPos && expandYPos) { newMaster.topL = masterNode; } else if (expandXPos && !expandYPos) { newMaster.botL = masterNode; } else if (!expandXPos && expandYPos) { newMaster.topR = masterNode; } else { newMaster.botR = masterNode; } masterNode = newMaster; } masterNode.addPoint(pt); }
public QDPoint getMidpoint() { if (midPoint == null) { midPoint = new QDPoint((start.x + finish.x) / 2.0f, (start.y + finish.y) / 2.0f); } return(midPoint); }
public float getDistToPoint(QDPoint pt) { float a = this.coeffs[0]; float b = this.coeffs[1]; float c = this.coeffs[2]; return((float)(Math.Abs(a * pt.x + b * pt.y + c) / Math.Sqrt(a * a + b * b))); }
private void calcCoeffs(QDPoint pt, float angleD) { float sinA = (float)Math.Sin(QDUtils.QDUtils.toRadians(angleD)); float cosA = (float)Math.Cos(QDUtils.QDUtils.toRadians(angleD)); coeffs.Add(sinA); coeffs.Add(-cosA); coeffs.Add(cosA * pt.y - sinA * pt.x); }
public QDLine(QDPoint start_in, QDPoint finish_in) { start = start_in; finish = finish_in; getMidpoint(); length = (float)Math.Pow(Math.Pow(start.x - finish.x, 2.0f) + Math.Pow(start.y - finish.y, 2.0f), 0.5f); angleR = (float)Math.Atan2(finish.y - start.y, finish.x - start.x); angleD = (float)toDegrees(angleR); //path.moveTo(start.x, start.y); //path.QDLineTo(finish.x,finish.y); }
//@Override public List <QDShapeDBPoint> getIntermediatePoints(float spacing) { List <QDShapeDBPoint> intermediatePoints = new List <QDShapeDBPoint>(); intermediatePoints.Add(new QDShapeDBPoint(centre, QDPointTypes.CIRCLE_CENTRE)); if (radius > spacing) { float angleR = 2.0f * (float)Math.Sin((spacing / 2.0f) / radius); int numPts = (int)Math.Ceiling(2.0f * Math.PI / angleR); float betweenPts = 2.0f * (float)Math.PI / numPts; for (int i = 1; i < numPts; i++) { QDPoint pt = new QDPoint(centre.x + (float)Math.Cos(-180.0f + i * betweenPts) * radius, centre.y + (float)Math.Sin(-180.0f + i * betweenPts) * radius); intermediatePoints.Add(new QDShapeDBPoint(pt, QDPointTypes.CIRCLE_CIRCUMFERENCE)); } } return(intermediatePoints); }
//@Override public override List <QDShapeDBPoint> getIntermediatePoints(float spacing) { List <QDShapeDBPoint> intermediateQDPoints = new List <QDShapeDBPoint>(); intermediateQDPoints.Add(new QDShapeDBPoint(start, QDPointTypes.LINE_START)); intermediateQDPoints.Add(new QDShapeDBPoint(finish, QDPointTypes.LINE_FINISH)); if (getLength() > spacing) { int numPts = (int)Math.Ceiling(getLength() / spacing); float betweenPts = getLength() / numPts; for (int i = 1; i < numPts; i++) { QDPoint pt = new QDPoint(start.x + (float)Math.Cos(angleR) * i * betweenPts, start.y + (float)Math.Sin(angleR) * i * betweenPts); intermediateQDPoints.Add(new QDShapeDBPoint(pt, QDPointTypes.LINE_INTERMEDIATE)); } } return(intermediateQDPoints); }
// Create intermediate QDPoints by sweeping around a standard elliptical arc shape then manually // applying the rotation and translation to the QDPoint. //@Override public override List <QDShapeDBPoint> getIntermediatePoints(float spacing) { List <QDShapeDBPoint> pts = new List <QDShapeDBPoint>(); // Get angle required to achieve desired QDPoint spacing at major axis extreme float angleStep = 2f * (float)Math.Atan(0.5f * spacing / mSemiX); // With a +ve CCW step, choose if we should sweep from start or finish to produce our arc float startSweep, finishSweep; if (direction == SweepDirection.Counterclockwise) { startSweep = QDUtils.QDUtils.degToRad(mStartAngleD); finishSweep = QDUtils.QDUtils.degToRad(mFinishAngleD); } else { startSweep = QDUtils.QDUtils.degToRad(mFinishAngleD); finishSweep = QDUtils.QDUtils.degToRad(mStartAngleD); } // Check whether the arc goes over the -pi barrier and adjust finish angle accordingly if (finishSweep < 0f && startSweep > finishSweep) { finishSweep += 2.0f * (float)Math.PI; } // Progress through the sweep for (float t = startSweep; t < finishSweep; t += angleStep) { QDPoint parametric = new QDPoint(mSemiX * (float)Math.Cos(t), mSemiY * (float)Math.Sin(t)); QDPoint rotatedPoint = new QDPoint((float)Math.Cos(mAngleR) * parametric.x - (float)Math.Sin(mAngleR) * parametric.y, (float)Math.Sin(mAngleR) * parametric.x + (float)Math.Cos(mAngleR) * parametric.y); QDPoint translatedPoint = new QDPoint(rotatedPoint.x + mCentre.x, rotatedPoint.y + mCentre.y); QDShapeDBPoint sampled = new QDShapeDBPoint(translatedPoint, QDPointTypes.CIRCLE_CIRCUMFERENCE); pts.Add(sampled); } return(pts); }
public QDInfiniteLine(QDPoint pt1, QDPoint pt2) { float angleR = (float)Math.Atan2(pt1.y - pt2.y, pt1.x - pt2.x); calcCoeffs(pt1, (float)QDUtils.QDUtils.toDegrees(angleR)); }
public QDInfiniteLine(QDPoint pt, float angleD) { calcCoeffs(pt, angleD); }
//private void writeObject(ObjectOutputStream oos) throws IOException { // // Default fields // oos.defaultWriteObject(); // // write the object // oos.writeInt(paint.getColor()); // oos.writeInt(paint.getAlpha()); // oos.writeFloat(paint.getStrokeWidth()); // oos.writeInt(Paint.Style.STROKE.ordinal()); // oos.writeInt(Paint.Join.ROUND.ordinal()); //} //private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException { // // default deserialization to fill the standard fields // ois.defaultReadObject(); // // read back the additional data in the order we wrote it // path = new Path(); // paint = new Paint(); // paint.setColor(ois.readInt()); // paint.setAlpha(ois.readInt()); // paint.setStrokeWidth(ois.readFloat()); // paint.setStyle(Paint.Style.values()[ois.readInt()]); // paint.setStrokeJoin(Paint.Join.values()[ois.readInt()]); //} protected QDPoint absToLocCoords(QDPoint absPt, float SF, QDPoint origin) { return(new QDPoint((absPt.x - origin.x) * SF, (absPt.y - origin.y) * SF)); }
public bool addPoint(QDPoint pt) { // Perform the check that the QDPoint is actually inside the region if (!this.contains(pt)) { return(false); } // If we're at size and have no children create them if (pts.Count >= child_per_branch && topL == null) { subdivide(); pts.Add(pt); foreach (QDPoint thisPt in pts) { if (topL.addPoint(thisPt)) { continue; // Alternatively consider making the contains check a part of the addPoint function itself so it will return whether its possible to add or not } if (topR.addPoint(thisPt)) { continue; } if (botL.addPoint(thisPt)) { continue; } if (botR.addPoint(thisPt)) { continue; } } pts.Clear(); } // if we already have children, add it to them else if (topL != null) { if (topL.addPoint(pt)) { return(true); } if (topR.addPoint(pt)) { return(true); } if (botL.addPoint(pt)) { return(true); } if (botR.addPoint(pt)) { return(true); } } // otherwise add it to the current node list else { pts.Add(pt); } return(true); }
public QDShapeDBPoint(QDPoint pt, QDPointTypes type_in) : base(pt) { type = type_in; }
// TODO: non-default direction - what does it even do? public QDCircle(QDPoint centrePt, float radiusLength) { centre = centrePt; radius = radiusLength; //direction = Path.Direction.CCW; }
public void getPoints(QDPoint pt, float radius, List <QDPoint> pts) { Square search = new Square(pt.x - radius, pt.y - radius, 2.0f * radius); masterNode.getPoints(search, pts); }
public QDPoint(QDPoint other) { this.x = other.x; this.y = other.y; }
public Boolean contains(QDPoint pt) { return(contains(pt.x, pt.y)); }