YouTube Music API request methods specifically for playlist manipulation
More...
|
| static bool | AddPlaylistItem (string cookieValue, string playlistId, string videoId, out Exception ex) |
| | HttpWebRequest POST request to send to add a playlist item (track) to an existing YouTube Music playlist More...
|
| |
| static bool | CreatePlaylist (string cookieValue, string title, string description, List< string > videoIds, PrivacyStatusEmum privacyStatus, out string playlistId, out string browseId, out Exception ex) |
| | HttpWebRequest POST request to send to YTM to create a new playlist More...
|
| |
| static bool | DeletePlaylist (string cookieValue, string playlistId, out string errorMessage) |
| | HttpWebRequest POST request to send to delete a playlist More...
|
| |
| static OnlinePlaylist | GetPlaylist (string cookieValue, string browseId, OnlinePlaylist playlist=null, string continuationToken=null) |
| | HttpWebRequest POST request to send to YTM, which gets a playlist given a playlist or browse id (You can get this from the 'Requests.Playlists.GetPlaylists (plural)') request method. And then recurisvely fetches all tracks listed in the playlist More...
|
| |
| static OnlinePlaylistCollection | GetPlaylists (string cookieValue, string continuationToken=null, OnlinePlaylistCollection playListCol=null) |
| | HttpWebRequest POST request to send to YTM which fetches a list (collection) of Playlists (without playlist tracks). Use the 'Requests.Playlists.GetPlaylist (singular)' method to get an individual playlist complete with track listing. More...
|
| |
| static bool | RemovePlaylistItems (string cookieValue, string playlistId, string videoEntityId, string setVideoEntityId, out string errorMessage) |
| | HttpWebRequest POST request to send to YTM to remove a playlist item (track) from an existing playlist More...
|
| |
YouTube Music API request methods specifically for playlist manipulation
◆ AddPlaylistItem()
| static bool YTMusicUploader.Providers.Requests.Playlists.AddPlaylistItem |
( |
string |
cookieValue, |
|
|
string |
playlistId, |
|
|
string |
videoId, |
|
|
out Exception |
ex |
|
) |
| |
|
static |
HttpWebRequest POST request to send to add a playlist item (track) to an existing YouTube Music playlist
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
| playlistId | YT Music playlistid (or browseId) to add to |
| videoId | This is the unique track id to add |
- Returns
- True if successfully, false otherwise
◆ CreatePlaylist()
| static bool YTMusicUploader.Providers.Requests.Playlists.CreatePlaylist |
( |
string |
cookieValue, |
|
|
string |
title, |
|
|
string |
description, |
|
|
List< string > |
videoIds, |
|
|
PrivacyStatusEmum |
privacyStatus, |
|
|
out string |
playlistId, |
|
|
out string |
browseId, |
|
|
out Exception |
ex |
|
) |
| |
|
static |
HttpWebRequest POST request to send to YTM to create a new playlist
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
| title | Title to call the playlist |
| description | Description of the playlist (does not allow HTML tags) |
| videoIds | List of video ids (track ids) to create the playlist with |
| privacyStatus | PRIVATE, PUBLIC or UNLISTED - Default it PUBLIC |
| playlistId | (Output) playlist id once created |
| browseId | (Output) browse id once create (It's just the playlist ID prefixed with 'VL') |
| errorMessage | (Output)Any error message encountered during the request |
- Returns
- True if request is successful, false otherwise
◆ DeletePlaylist()
| static bool YTMusicUploader.Providers.Requests.Playlists.DeletePlaylist |
( |
string |
cookieValue, |
|
|
string |
playlistId, |
|
|
out string |
errorMessage |
|
) |
| |
|
static |
HttpWebRequest POST request to send to delete a playlist
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
| playlistId | Playlist id (or browse id) to delete |
| errorMessage | (Output) error message from error encountered during the request |
- Returns
- True if request is successful, false otherwise
◆ GetPlaylist()
| static OnlinePlaylist YTMusicUploader.Providers.Requests.Playlists.GetPlaylist |
( |
string |
cookieValue, |
|
|
string |
browseId, |
|
|
OnlinePlaylist |
playlist = null , |
|
|
string |
continuationToken = null |
|
) |
| |
|
static |
HttpWebRequest POST request to send to YTM, which gets a playlist given a playlist or browse id (You can get this from the 'Requests.Playlists.GetPlaylists (plural)') request method. And then recurisvely fetches all tracks listed in the playlist
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
| browseId | Playlist id or browse id to retreive the playlist for |
| playlist | Shuuld be null initially. This object is used for recursive purposes |
| continuationToken | Should be null initially. This object is used for recursive purposes. |
- Returns
- OnlinePlaylist object
◆ GetPlaylists()
| static OnlinePlaylistCollection YTMusicUploader.Providers.Requests.Playlists.GetPlaylists |
( |
string |
cookieValue, |
|
|
string |
continuationToken = null , |
|
|
OnlinePlaylistCollection |
playListCol = null |
|
) |
| |
|
static |
HttpWebRequest POST request to send to YTM which fetches a list (collection) of Playlists (without playlist tracks). Use the 'Requests.Playlists.GetPlaylist (singular)' method to get an individual playlist complete with track listing.
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
- Returns
- OnlinePlaylistCollection object (list of playlists without tracks)
◆ RemovePlaylistItems()
| static bool YTMusicUploader.Providers.Requests.Playlists.RemovePlaylistItems |
( |
string |
cookieValue, |
|
|
string |
playlistId, |
|
|
string |
videoEntityId, |
|
|
string |
setVideoEntityId, |
|
|
out string |
errorMessage |
|
) |
| |
|
static |
HttpWebRequest POST request to send to YTM to remove a playlist item (track) from an existing playlist
- Parameters
-
| cookieValue | Cookie from a previous YouTube Music sign in via this application (stored in the database) |
| playlistId | Playlist id to remove a track from |
| videoEntityId | VideoId (unique track entityId) of the track to remove |
| setVideoEntityId | SetVideoId (alt unbique track entityId) of the track to remove |
| errorMessage | (Output) Error message if error encountered while sending the request |
- Returns
- True if the request was successful, false otherwise
The documentation for this class was generated from the following files:
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/AddPlaylistItems.cs
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/CreatePlaylist.cs
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/DeletePlaylist.cs
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/GetPlaylist.cs
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/GetPlaylists.cs
- D:/Repositories/YTMusicUploader/YTMusicUploader/Providers/Requests/Playlists/RemovePlaylistItems.cs


{% extends 'base.html' %} {% load static %} {% block content %} Face Recognition Detect faces from picture Detect features from face Compare any two person picture for finding whether they belong to same person or not Detect Features Compare {% endblock %}


Cocoa is a complete set of classes and application programming interfaces (APIs) for building Mac OS X
applications and tools. With over 240 classes, Cocoa is divided into two essential frameworks: the
Foundation framework and the Application Kit.
The Foundation framework provides a fundamental set of tools for representing fundamental data types,
accessing operating system services, threading, messaging, and more. The Application Kit provides the
functionality to build graphical user interfaces (GUI) for Cocoa applications. It provides access to the
standard Aqua interface components ranging from menus, buttons, and text fields—the building blocks of
larger interfaces—to complete, prepackaged interfaces for print dialogs, file operation dialogs, and alert
dialogs. The Application Kit also provides higher-level functionality to implement multiple document
applications, text handling, and graphics.
Classes are not the only constituents of the Cocoa frameworks. Some programming tasks, such as
sounding a system beep, are best accomplished with a simple C function. Cocoa includes a number of
functions for accomplishing tasks such as manipulating byte orders and drawing simple graphics.
Additionally, Cocoa defines a number of custom data types and constants to provide a higher degree of
abstraction to many method parameters.
What Is Cocoa?


The CellMLAnnotationView plugin can be used to annotate CellML files. If you open a CellML file that does not contain any annotation, then it will look something like this:
All the CellML elements that can be annotated are listed to the left of the view. If you right click on any of them, you will get a popup menu, which you can use to expand/collapse all the child nodes, as well as remove the metadata associated with the current CellML element or the whole CellML file:
Say that you want to annotate the sodium_channel
component. First, you need to select it:
Next, you need to specify a BioModels.net qualifier. If you do not know which one to use, click on the button to get some information about the current BioModels.net qualifier:
From there, go through the list of BioModels.net qualifiers until you find the one that suits your needs best. Here, we will say that you want to use bio:isVersionOf
:
Now, you need to retrieve some possible ontological terms to describe the sodium_channel
component. For this, you must enter a search term, which in our case is going to be sodium channel
(note: regular expressions are supported). As can be seen, OpenCOR returns 12 possible ontological terms:
A quick look through the list tells us that you might want to use the one for voltage-gated sodium channel complex
. If you want to know more about the GO resource, you can click on its corresponding link:
Similarly, if you want to know more about the GO identifier:
Now, assuming that you are happy with your choice of ontological term, you can associate it with the sodium_channel
component by clicking on its corresponding button:
As you can see, the ontological term you have added cannot be added anymore, but it can be removed by clicking on its corresponding button or by using the context menu (see above).
Now, say that you also want to add another ontological term. You can obviously do so by clicking on its corresponding button, but you can also enter its resource-id duple, e.g. go/GO:0005248
(i.e. <resource>/<id>
) in the term field.  OpenCOR recognises RDF triples which subject identifies a CellML element while it expects the predicate to be a BioModels.net qualifier and the object an ontological term.
Ontological terms used to be identified using MIRIAM URNs, but these have now been deprecated in favour of identifiers.org URIs. OpenCOR recognises both, but it will only serialise annotations using identifiers.org URIs.
Now, it may happen that a file contains annotations that are not recognised by OpenCOR. In this case, OpenCOR will display the annotations as a simple list of RDF triples:
If you ever come across such a type of annotations and think that OpenCOR ought to recognise it, then please do let us know.


Item recorded. Upload successful.
View in Tangle Explorer
IOTA and Heroku do not sponsor, endorse or have any affiliation with this project.


{% extends "blog/base_with_nav.html"%} {% block title %} About Us {% endblock %} {% load static %} {% block content %}
It's been wonderful working with django.Connecting with other developers in order to learn and share ideas is all that this platform is about,so let's all connect and keep on djangoing.
Connect with Gabriel


Bristol University students fly home from Hong Kong as protests escalate
Bristol University says students' safety is the priority
by Andrew McQuarrieA number of Bristol University students based in Hong Kong have decided to fly home amid protests in the city.
Pro-democracy campaigners have been using Hong Kong Polytechnic University as a base for demonstrations, which have included the throwing of petrol bombs.
Tear gas and rubber bullets have been used against the protesters, who could face penalties of up to 10 years.
A University of Bristol spokesperson revealed today (November 19) that six out of 15 students have already returned to their home country.
Through a statement produced yesterday, a university spokesperson said: “Given the increase in the protests in recent days we have proactively offered to repatriate all our students.”
The full statement reads: “Like many other UK universities, we do have a small number of students currently studying and living in Hong Kong.
“We have 15 students studying and working in four different universities in Hong Kong on placements, exchange or study abroad programmes.
“We have stayed in close contact with them since they went to Hong Kong in September and have been monitoring the situation carefully.
“Given the increase in the protests in recent days we have proactively offered to repatriate all our students.
“We will continue to monitor security advice from our insurers and the FCO and will provide ongoing support to students if they wish to stay in Hong Kong.
“Flights are being booked for students who wish to return and staff will work with them to identify options for the rest of their year to ensure there is no detrimental impact on their studies as a result.
“Our priority is to ensure the safety and wellbeing of all students and travelling staff.”
For the latest news in and around Bristol, visit and bookmark Bristol Live's homepage .


T
he
P
rojects of
M
ichael
V
erthein
Home
Blog
About
Resume
Ruby Cheat Sheet (work in progress)
Project 2
Project 3
Project 4
Project 5


Keep multiple panels open at once
- Vietnam
-
Vietnam is the easternmost country on the Indochina Peninsula. With an estimated 94.6 million inhabitants as of 2016, it is the 15th most populous country in the world. Vietnam is bordered by China to the north, Laos and Cambodia to the west, part of Thailand to the southwest, and the Philippines, Malaysia, and Indonesia across the South China Sea to the east and southeast.
Its capital city has been Hanoi since the reunification of North and South Vietnam in 1976, while its most populous city is Ho Chi Minh City.
- Cambodia
-
Cambodia is a country located in the southern portion of the Indochina peninsula in Southeast Asia. It is 181,035 square kilometres (69,898 square miles) in area, bordered by Thailand to the northwest, Laos to the northeast, Vietnam to the east and the Gulf of Thailand to the southwest.
The sovereign state of Cambodia has a population of over 16 million. The official religion is Theravada Buddhism, practised by approximately 95 percent of the population.
- Laos
-
Laos, commonly referred to by its colloquial name of Muang Lao, is a socialist state and the only landlocked country in Southeast Asia.
Located at the heart of the Indochinese peninsula, Laos is bordered by Myanmar (Burma) and China to the northwest, Vietnam to the east, Cambodia to the southwest, and Thailand to the west and southwest.
- Lorem Ipsum Bonus Section


| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
InteriorPointArea.centre(Envelope envelope)
Returns the centre point of the envelope.
|
Coordinate |
MinimumBoundingCircle.getCentre()
Gets the centre point of the computed Minimum Bounding Circle.
|
Coordinate |
Centroid.getCentroid()
Gets the computed centroid.
|
Coordinate |
CentroidLine.getCentroid()
Deprecated.
|
Coordinate |
CentroidPoint.getCentroid()
Deprecated.
|
Coordinate |
CentroidArea.getCentroid()
Deprecated.
|
static Coordinate |
Centroid.getCentroid(Geometry geom)
Computes the centroid point of a geometry.
|
Coordinate |
HCoordinate.getCoordinate() |
Coordinate |
LineIntersector.getEndpoint(int segmentIndex,
int ptIndex)
Gets an endpoint of an input segment.
|
Coordinate[] |
MinimumBoundingCircle.getExtremalPoints()
Gets the extremal points which define the computed Minimum Bounding Circle.
|
Coordinate |
InteriorPointArea.getInteriorPoint()
Gets the computed interior point.
|
Coordinate |
InteriorPointPoint.getInteriorPoint() |
Coordinate |
InteriorPointLine.getInteriorPoint() |
Coordinate |
CentralEndpointIntersector.getIntersection()
Deprecated.
|
static Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
Coordinate |
LineIntersector.getIntersection(int intIndex)
Returns the intIndex'th intersection point
|
Coordinate |
LineIntersector.getIntersectionAlongSegment(int segmentIndex,
int intIndex)
Computes the intIndex'th intersection point in the direction of
a specified input line segment
|
Coordinate |
MinimumDiameter.getWidthCoordinate()
Gets the
Coordinate forming one end of the minimum diameter |
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments
using homogeneous coordinates.
|
| Modifier and Type | Method and Description |
|---|---|
void |
CentroidPoint.add(Coordinate pt)
Deprecated.
Adds the length defined by an array of coordinates.
|
void |
CentroidLine.add(Coordinate[] pts)
Deprecated.
Adds the length defined by an array of coordinates.
|
void |
CentroidArea.add(Coordinate[] ring)
Deprecated.
Adds the area defined by an array of
coordinates.
|
static double |
Angle.angle(Coordinate p)
Returns the angle that the vector from (0,0) to p,
relative to the positive X-axis.
|
static double |
Angle.angle(Coordinate p0,
Coordinate p1)
Returns the angle of the vector from p0 to p1,
relative to the positive X-axis.
|
static double |
Angle.angleBetween(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the unoriented smallest angle between two vectors.
|
static double |
Angle.angleBetweenOriented(Coordinate tip1,
Coordinate tail,
Coordinate tip2)
Returns the oriented smallest angle between two vectors.
|
static double |
LineIntersector.computeEdgeDistance(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the "edge distance" of an intersection point p along a segment.
|
abstract void |
LineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2)
Compute the intersection of a point p and the line p1-p2.
|
void |
RobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2) |
void |
NonRobustLineIntersector.computeIntersection(Coordinate p,
Coordinate p1,
Coordinate p2) |
void |
LineIntersector.computeIntersection(Coordinate p1,
Coordinate p2,
Coordinate p3,
Coordinate p4)
Computes the intersection of the lines p1-p2 and p3-p4.
|
static int |
CGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Computes the orientation of a point q to the directed line segment p1-p2.
|
static int |
NonRobustCGAlgorithms.computeOrientation(Coordinate p1,
Coordinate p2,
Coordinate q)
Computes the orientation of a point q to the directed line segment p1-p2.
|
void |
RayCrossingCounter.countSegment(Coordinate p1,
Coordinate p2)
Counts a segment
|
static double |
CGAlgorithms3D.distance(Coordinate p0,
Coordinate p1) |
static double |
CGAlgorithms.distanceLineLine(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance from a line segment AB to a line segment CD
Note: NON-ROBUST!
|
static double |
NonRobustCGAlgorithms.distanceLineLine(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance from a line segment AB to a line segment CD
Note: NON-ROBUST!
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate[] line)
Computes the distance from a point to a sequence of line segments.
|
static double |
CGAlgorithms.distancePointLine(Coordinate p,
Coordinate A,
Coordinate B)
Computes the distance from a point p to a line segment AB
Note: NON-ROBUST!
|
static double |
CGAlgorithms.distancePointLinePerpendicular(Coordinate p,
Coordinate A,
Coordinate B)
Computes the perpendicular distance from a point p to the (infinite) line
containing the points AB
|
static double |
CGAlgorithms3D.distancePointSegment(Coordinate p,
Coordinate A,
Coordinate B) |
static double |
CGAlgorithms3D.distanceSegmentSegment(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the distance between two 3D segments.
|
static Coordinate |
CentralEndpointIntersector.getIntersection(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
static double |
Angle.interiorAngle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Computes the interior angle between two segments of a ring.
|
static Coordinate |
CGAlgorithmsDD.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes an intersection point between two lines
using DD arithmetic.
|
static Coordinate |
HCoordinate.intersection(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Computes the (approximate) intersection point between two line segments
using homogeneous coordinates.
|
boolean |
RectangleLineIntersector.intersects(Coordinate p0,
Coordinate p1)
Tests whether the query rectangle intersects a
given line segment.
|
boolean |
PointLocator.intersects(Coordinate p,
Geometry geom)
Convenience method to test a point for intersection with
a Geometry
|
static boolean |
Angle.isAcute(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is acute.
|
static boolean |
CGAlgorithms.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate s is
oriented counter-clockwise. |
static boolean |
NonRobustCGAlgorithms.isCCW(Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
boolean |
MCPointInRing.isInside(Coordinate pt) |
boolean |
SimplePointInRing.isInside(Coordinate pt) |
boolean |
PointInRing.isInside(Coordinate pt) |
boolean |
LineIntersector.isIntersection(Coordinate pt)
Test whether a point is a intersection point of two line segments.
|
static boolean |
Angle.isObtuse(Coordinate p0,
Coordinate p1,
Coordinate p2)
Tests whether the angle between p0-p1-p2 is obtuse.
|
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of
coordinates.
|
static boolean |
CGAlgorithms.isOnLine(Coordinate p,
Coordinate[] pt)
Tests whether a point lies on the line segments defined by a list of
coordinates.
|
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
static boolean |
CGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Tests whether a point lies inside or on a ring.
|
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
static boolean |
NonRobustCGAlgorithms.isPointInRing(Coordinate p,
Coordinate[] ring)
Computes whether a ring defined by an array of
Coordinate is
oriented counter-clockwise. |
int |
PointLocator.locate(Coordinate p,
Geometry geom)
Computes the topological relationship (
Location ) of a single point
to a Geometry. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the
Location of a point in a ring. |
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines the
Location of a point in a ring. |
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
static int |
CGAlgorithms.locatePointInRing(Coordinate p,
Coordinate[] ring)
Determines whether a point lies in the interior, on the boundary, or in the
exterior of a ring.
|
static int |
RayCrossingCounter.locatePointInRing(Coordinate p,
CoordinateSequence ring)
Determines the
Location of a point in a ring. |
static double |
LineIntersector.nonRobustComputeEdgeDistance(Coordinate p,
Coordinate p1,
Coordinate p2)
This function is non-robust, since it may compute the square of large numbers.
|
static int |
RobustDeterminant.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static int |
CGAlgorithmsDD.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static int |
CGAlgorithms.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static int |
NonRobustCGAlgorithms.orientationIndex(Coordinate p1,
Coordinate p2,
Coordinate q)
Returns the index of the direction of the point
q relative to
a vector specified by p1-p2 . |
static double |
CGAlgorithms.signedArea(Coordinate[] ring)
Computes the signed area for a ring.
|
| Constructor and Description |
|---|
CentralEndpointIntersector(Coordinate p00,
Coordinate p01,
Coordinate p10,
Coordinate p11)
Deprecated.
|
ConvexHull(Coordinate[] pts,
GeometryFactory geomFactory)
Create a new convex hull construction for the input
Coordinate array. |
HCoordinate(Coordinate p) |
HCoordinate(Coordinate p1,
Coordinate p2)
Constructs a homogeneous coordinate which is the intersection of the lines
define by the homogenous coordinates represented by two
Coordinate s. |
HCoordinate(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2) |
RayCrossingCounter(Coordinate p) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
PointPairDistance.getCoordinates() |
Coordinate[] |
DiscreteHausdorffDistance.getCoordinates() |
| Modifier and Type | Method and Description |
|---|---|
static void |
DistanceToPoint.computeDistance(Geometry geom,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(LineSegment segment,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(LineString line,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPoint.computeDistance(Polygon poly,
Coordinate pt,
PointPairDistance ptDist) |
void |
DiscreteHausdorffDistance.MaxPointDistanceFilter.filter(Coordinate pt) |
void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
SimplePointInAreaLocator.containsPointInPolygon(Coordinate p,
Polygon poly) |
int |
SimplePointInAreaLocator.locate(Coordinate p) |
int |
IndexedPointInAreaLocator.locate(Coordinate p)
|
int |
PointOnGeometryLocator.locate(Coordinate p)
|
static int |
SimplePointInAreaLocator.locate(Coordinate p,
Geometry geom)
|
| Modifier and Type | Method and Description |
|---|---|
void |
IdentityPointTransformation.transform(Coordinate model,
java.awt.geom.Point2D view) |
void |
PointTransformation.transform(Coordinate src,
java.awt.geom.Point2D dest)
Transforms a
Coordinate into a Java2D Point . |
| Constructor and Description |
|---|
PolygonShape(Coordinate[] shellVertices,
java.util.Collection holeVerticesCollection)
Creates a new polygon
Shape . |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
HalfEdge.dest()
Gets the destination coordinate of this edge.
|
Coordinate |
HalfEdge.orig()
Gets the origin coordinate of this edge.
|
| Modifier and Type | Method and Description |
|---|---|
HalfEdge |
EdgeGraph.addEdge(Coordinate orig,
Coordinate dest)
Adds an edge between the coordinates orig and dest
to this graph.
|
static HalfEdge |
HalfEdge.create(Coordinate p0,
Coordinate p1)
Creates a HalfEdge pair representing an edge
between two vertices located at coordinates p0 and p1.
|
boolean |
HalfEdge.equals(Coordinate p0,
Coordinate p1)
Tests whether this edge has the given orig and dest vertices.
|
HalfEdge |
HalfEdge.find(Coordinate dest)
Finds the edge starting at the origin of this edge
with the given dest vertex,
if any.
|
HalfEdge |
EdgeGraph.findEdge(Coordinate orig,
Coordinate dest)
Finds an edge in this graph with the given origin
and destination, if one exists.
|
static boolean |
EdgeGraph.isValidEdge(Coordinate orig,
Coordinate dest)
Tests if the given coordinates form a valid edge (with non-zero length).
|
| Constructor and Description |
|---|
HalfEdge(Coordinate orig)
Creates an edge originating from a given coordinate.
|
MarkHalfEdge(Coordinate orig)
Creates a new marked edge.
|
| Modifier and Type | Field and Description |
|---|---|
Coordinate |
Triangle.p0
The coordinates of the vertices of the triangle
|
Coordinate |
LineSegment.p0 |
Coordinate |
Triangle.p1
The coordinates of the vertices of the triangle
|
Coordinate |
LineSegment.p1 |
Coordinate |
Triangle.p2
The coordinates of the vertices of the triangle
|
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment
AC.
|
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the
given amount, or an empty coordinate array.
|
Coordinate |
Envelope.centre()
Computes the coordinate of the centre of this envelope (as long as it is non-null
|
Coordinate |
Triangle.centroid()
Computes the centroid (centre of mass) of this triangle.
|
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle.
|
Coordinate |
Triangle.circumcentre()
Computes the circumcentre of this triangle.
|
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point.
|
Coordinate[] |
LineSegment.closestPoints(LineSegment line)
Computes the closest points on two line segments.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
|
Coordinate |
LineString.getCoordinate() |
Coordinate |
Point.getCoordinate() |
Coordinate |
GeometryCollection.getCoordinate() |
Coordinate |
Polygon.getCoordinate() |
abstract Coordinate |
Geometry.getCoordinate()
Returns a vertex of this
Geometry
(usually, but not necessarily, the first one). |
Coordinate |
TopologyException.getCoordinate() |
Coordinate |
CoordinateSequence.getCoordinate(int i)
Returns (possibly a copy of) the i'th coordinate in this sequence.
|
Coordinate |
LineSegment.getCoordinate(int i) |
Coordinate |
CoordinateList.getCoordinate(int i) |
Coordinate |
CoordinateSequence.getCoordinateCopy(int i)
Returns a copy of the i'th coordinate in this sequence.
|
Coordinate |
LineString.getCoordinateN(int n) |
Coordinate[] |
LineString.getCoordinates() |
Coordinate[] |
Point.getCoordinates() |
Coordinate[] |
GeometryCollection.getCoordinates()
Collects all coordinates of all subgeometries into an Array.
|
Coordinate[] |
Polygon.getCoordinates() |
abstract Coordinate[] |
Geometry.getCoordinates()
Returns an array containing the values of all the vertices for
this geometry.
|
Coordinate |
Triangle.inCentre()
Computes the incentre of this triangle.
|
static Coordinate |
Triangle.inCentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the incentre of a triangle.
|
static Coordinate[] |
CoordinateArrays.intersection(Coordinate[] coordinates,
Envelope env)
Extracts the coordinates which intersect an
Envelope . |
Coordinate |
LineSegment.intersection(LineSegment line)
Computes an intersection point between two line segments, if there is one.
|
Coordinate |
LineSegment.lineIntersection(LineSegment line)
Computes the intersection point of the lines of infinite extent defined
by two line segments (if there is one).
|
Coordinate |
LineSegment.midPoint()
Computes the midpoint of the segment
|
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment
|
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison.
|
Coordinate |
LineSegment.pointAlong(double segmentLengthFraction)
Computes the
Coordinate that lies a given
fraction along the line defined by this segment. |
Coordinate |
LineSegment.pointAlongOffset(double segmentLengthFraction,
double offsetDistance)
Computes the
Coordinate that lies a given
fraction along the line defined by this segment and offset from
the segment by a given distance. |
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined
by this line segment.
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
Coordinate[] |
CoordinateSequence.toCoordinateArray()
Returns (possibly copies of) the Coordinates in this collection.
|
Coordinate[] |
CoordinateList.toCoordinateArray()
Returns the Coordinates in this collection.
|
static Coordinate[] |
CoordinateArrays.toCoordinateArray(java.util.Collection coordList)
Converts the given Collection of Coordinates into a Coordinate array.
|
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated.
no longer needed, since internal representation is same as external representation
|
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated.
use makePrecise instead
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated)
Adds an array of coordinates to the list.
|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
boolean direction)
Adds an array of coordinates to the list.
|
boolean |
CoordinateList.add(Coordinate[] coord,
boolean allowRepeated,
int start,
int end)
Adds a section of an array of coordinates to the list.
|
void |
CoordinateList.add(Coordinate coord,
boolean allowRepeated)
Adds a coordinate to the end of the list.
|
void |
CoordinateList.add(int i,
Coordinate coord,
boolean allowRepeated)
Inserts the specified coordinate at the specified position in this list.
|
static Coordinate |
Triangle.angleBisector(Coordinate a,
Coordinate b,
Coordinate c)
Computes the point at which the bisector of the angle ABC cuts the segment
AC.
|
static double |
Triangle.area(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 2D area of a triangle.
|
static double |
Triangle.area3D(Coordinate a,
Coordinate b,
Coordinate c)
Computes the 3D area of a triangle.
|
static Coordinate[] |
CoordinateArrays.atLeastNCoordinatesOrNothing(int n,
Coordinate[] c)
Returns either the given coordinate array if its length is greater than the
given amount, or an empty coordinate array.
|
static Coordinate |
Triangle.centroid(Coordinate a,
Coordinate b,
Coordinate c)
Computes the centroid (centre of mass) of a triangle.
|
static Coordinate |
Triangle.circumcentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the circumcentre of a triangle.
|
Coordinate |
LineSegment.closestPoint(Coordinate p)
Computes the closest point on this line segment to another point.
|
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
static int |
CoordinateArrays.compare(Coordinate[] pts1,
Coordinate[] pts2)
Compares two
Coordinate arrays
in the forward direction of their coordinates,
using lexicographic ordering. |
boolean |
Envelope.contains(Coordinate p)
Tests if the given point lies in or on the envelope.
|
static Coordinate[] |
CoordinateArrays.copyDeep(Coordinate[] coordinates)
Creates a deep copy of the argument
Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
static void |
CoordinateArrays.copyDeep(Coordinate[] src,
int srcStart,
Coordinate[] dest,
int destStart,
int length)
Creates a deep copy of a given section of a source
Coordinate array
into a destination Coordinate array. |
boolean |
Envelope.covers(Coordinate p)
Tests if the given point lies in or on the envelope.
|
CoordinateSequence |
CoordinateSequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateSequence based on the given array. |
CoordinateSequence |
DefaultCoordinateSequenceFactory.create(Coordinate[] coordinates)
Deprecated.
Returns a DefaultCoordinateSequence based on the given array (the array is
not copied).
|
LinearRing |
GeometryFactory.createLinearRing(Coordinate[] coordinates)
Creates a
LinearRing using the given Coordinate s. |
LineString |
GeometryFactory.createLineString(Coordinate[] coordinates)
Creates a LineString using the given Coordinates.
|
MultiPoint |
GeometryFactory.createMultiPoint(Coordinate[] coordinates)
Creates a
MultiPoint using the given Coordinate s. |
Point |
GeometryFactory.createPoint(Coordinate coordinate)
Creates a Point using the given Coordinate.
|
static Point |
GeometryFactory.createPointFromInternalCoord(Coordinate coord,
Geometry exemplar) |
Polygon |
GeometryFactory.createPolygon(Coordinate[] coordinates)
Constructs a
Polygon with the given exterior boundary. |
double |
LineSegment.distance(Coordinate p)
Computes the distance between this line segment and a given point.
|
double |
Coordinate.distance(Coordinate c)
Computes the 2-dimensional Euclidean distance to another location.
|
double |
Coordinate.distance3D(Coordinate c)
Computes the 3-dimensional Euclidean distance to another location.
|
double |
LineSegment.distancePerpendicular(Coordinate p)
Computes the perpendicular distance between the (infinite) line defined
by this line segment and a point.
|
static Envelope |
CoordinateArrays.envelope(Coordinate[] coordinates)
Computes the envelope of the coordinates.
|
boolean |
Coordinate.equalInZ(Coordinate c,
double tolerance)
Tests if another coordinate has the same value for Z, within a tolerance.
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise
equal (as compared using Coordinate#equals)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2)
Returns true if the two arrays are identical, both null, or pointwise
equal (as compared using Coordinate#equals)
|
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
java.util.Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise
equal, using a user-defined
Comparator for Coordinate s |
static boolean |
CoordinateArrays.equals(Coordinate[] coord1,
Coordinate[] coord2,
java.util.Comparator coordinateComparator)
Returns true if the two arrays are identical, both null, or pointwise
equal, using a user-defined
Comparator for Coordinate s |
boolean |
Coordinate.equals2D(Coordinate other)
Returns whether the planar projections of the two
Coordinate s
are equal. |
boolean |
Coordinate.equals2D(Coordinate c,
double tolerance)
Tests if another coordinate has the same values for the X and Y ordinates.
|
boolean |
Coordinate.equals3D(Coordinate other)
Tests if another coordinate has the same values for the X, Y and Z ordinates.
|
void |
Envelope.expandToInclude(Coordinate p)
Enlarges this
Envelope so that it contains
the given Coordinate . |
OctagonalEnvelope |
OctagonalEnvelope.expandToInclude(Coordinate p) |
static Coordinate[] |
CoordinateArrays.extract(Coordinate[] pts,
int start,
int end)
|
void |
CoordinateFilter.filter(Coordinate coord)
Performs an operation with the
coord . |
void |
CoordinateSequence.getCoordinate(int index,
Coordinate coord)
Copies the i'th coordinate in the sequence to the supplied
Coordinate . |
static boolean |
CoordinateArrays.hasRepeatedPoints(Coordinate[] coord)
Returns whether #equals returns true for any two consecutive Coordinates
in the given array.
|
static Coordinate |
Triangle.inCentre(Coordinate a,
Coordinate b,
Coordinate c)
Computes the incentre of a triangle.
|
static int |
CoordinateArrays.increasingDirection(Coordinate[] pts)
Determines which orientation of the
Coordinate array
is (overall) increasing. |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of
coordinate in coordinates . |
static int |
CoordinateArrays.indexOf(Coordinate coordinate,
Coordinate[] coordinates)
Returns the index of
coordinate in coordinates . |
void |
Envelope.init(Coordinate p)
Initialize an
Envelope to a region defined by a single Coordinate. |
void |
Envelope.init(Coordinate p1,
Coordinate p2)
Initialize an
Envelope to a region defined by two Coordinates. |
double |
Triangle.interpolateZ(Coordinate p)
Computes the Z-value (elevation) of an XY point on a three-dimensional
plane defined by this triangle (whose vertices must have Z-values).
|
static double |
Triangle.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Computes the Z-value (elevation) of an XY point on a three-dimensional
plane defined by a triangle whose vertices have Z-values.
|
static Coordinate[] |
CoordinateArrays.intersection(Coordinate[] coordinates,
Envelope env)
Extracts the coordinates which intersect an
Envelope . |
boolean |
Envelope.intersects(Coordinate p)
Check if the point
p
overlaps (lies inside) the region of this Envelope . |
boolean |
OctagonalEnvelope.intersects(Coordinate p) |
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q)
Test the point q to see whether it intersects the Envelope defined by p1-p2
|
static boolean |
Envelope.intersects(Coordinate p1,
Coordinate p2,
Coordinate q1,
Coordinate q2)
Tests whether the envelope defined by p1-p2
and the envelope defined by q1-q2
intersect.
|
static boolean |
Triangle.isAcute(Coordinate a,
Coordinate b,
Coordinate c)
Tests whether a triangle is acute.
|
boolean |
LineString.isCoordinate(Coordinate pt)
Returns true if the given point is a vertex of this
LineString . |
static boolean |
CoordinateArrays.isRing(Coordinate[] pts)
Tests whether an array of
Coordinate s forms a ring,
by checking length and closure. |
static double |
Triangle.longestSideLength(Coordinate a,
Coordinate b,
Coordinate c)
Computes the length of the longest side of a triangle
|
void |
PrecisionModel.makePrecise(Coordinate coord)
Rounds a Coordinate to the PrecisionModel grid.
|
static Coordinate |
LineSegment.midPoint(Coordinate p0,
Coordinate p1)
Computes the midpoint of a segment
|
static Coordinate |
CoordinateArrays.minCoordinate(Coordinate[] coordinates)
Returns the minimum coordinate, using the usual lexicographic comparison.
|
int |
LineSegment.orientationIndex(Coordinate p)
Determines the orientation index of a
Coordinate relative to this segment. |
boolean |
Envelope.overlaps(Coordinate p)
Deprecated.
Use #intersects instead.
|
static HCoordinate |
Triangle.perpendicularBisector(Coordinate a,
Coordinate b)
Computes the line which is the perpendicular bisector of the line segment
a-b.
|
Coordinate |
LineSegment.project(Coordinate p)
Compute the projection of a point onto the line determined
by this line segment.
|
double |
LineSegment.projectionFactor(Coordinate p)
Computes the Projection Factor for the projection of the point p
onto this LineSegment.
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate |
CoordinateArrays.ptNotInList(Coordinate[] testPts,
Coordinate[] pts)
Finds a point in a list of points which is not contained in another list of points
|
static Coordinate[] |
CoordinateArrays.removeNull(Coordinate[] coord)
Collapses a coordinate array to remove all null elements.
|
static Coordinate[] |
CoordinateArrays.removeRepeatedPoints(Coordinate[] coord)
If the coordinate array argument has repeated points,
constructs a new array containing no repeated points.
|
static void |
CoordinateArrays.reverse(Coordinate[] coord)
Reverses the coordinates in an array in-place.
|
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
static void |
CoordinateArrays.scroll(Coordinate[] coordinates,
Coordinate firstCoordinate)
Shifts the positions of the coordinates until
firstCoordinate
is first. |
double |
LineSegment.segmentFraction(Coordinate inputPt)
Computes the fraction of distance (in [0.0, 1.0])
that the projection of a point occurs along this line segment.
|
void |
Coordinate.setCoordinate(Coordinate other)
Sets this
Coordinate s (x,y,z) values to that of other . |
void |
LineSegment.setCoordinates(Coordinate p0,
Coordinate p1) |
static double |
Triangle.signedArea(Coordinate a,
Coordinate b,
Coordinate c)
Computes the signed 2D area of a triangle.
|
Coordinate |
PrecisionModel.toExternal(Coordinate internal)
Deprecated.
no longer needed, since internal representation is same as external representation
|
void |
PrecisionModel.toExternal(Coordinate internal,
Coordinate external)
Deprecated.
no longer needed, since internal representation is same as external representation
|
Coordinate |
PrecisionModel.toInternal(Coordinate external)
Deprecated.
use makePrecise instead
|
void |
PrecisionModel.toInternal(Coordinate external,
Coordinate internal)
Deprecated.
use makePrecise instead
|
| Constructor and Description |
|---|
Coordinate(Coordinate c)
Constructs a
Coordinate having the same (x,y,z) values as
other . |
CoordinateList(Coordinate[] coord)
Constructs a new list from an array of Coordinates, allowing repeated points.
|
CoordinateList(Coordinate[] coord,
boolean allowRepeated)
Constructs a new list from an array of Coordinates,
allowing caller to specify if repeated points are to be removed.
|
Envelope(Coordinate p)
Creates an
Envelope for a region defined by a single Coordinate. |
Envelope(Coordinate p1,
Coordinate p2)
Creates an
Envelope for a region defined by two Coordinates. |
LinearRing(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
LineSegment(Coordinate p0,
Coordinate p1) |
LineString(Coordinate[] points,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
OctagonalEnvelope(Coordinate p)
Creates a new null bounding octagon bounding a
Coordinate |
OctagonalEnvelope(Coordinate p0,
Coordinate p1)
Creates a new null bounding octagon bounding a pair of
Coordinate s |
Point(Coordinate coordinate,
PrecisionModel precisionModel,
int SRID)
Deprecated.
Use GeometryFactory instead
|
TopologyException(java.lang.String msg,
Coordinate pt) |
Triangle(Coordinate p0,
Coordinate p1,
Coordinate p2)
Creates a new triangle with the given vertices.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
CoordinateArraySequence.getCoordinate(int i)
Get the Coordinate with index i.
|
Coordinate |
PackedCoordinateSequence.getCoordinate(int i) |
Coordinate |
CoordinateArraySequence.getCoordinateCopy(int i)
Get a copy of the Coordinate with index i.
|
Coordinate |
PackedCoordinateSequence.getCoordinateCopy(int i) |
Coordinate |
PackedCoordinateSequence.Double.getCoordinateInternal(int i) |
Coordinate |
PackedCoordinateSequence.Float.getCoordinateInternal(int i) |
Coordinate[] |
CoordinateArraySequence.toCoordinateArray()
This method exposes the internal Array of Coordinate Objects
|
Coordinate[] |
PackedCoordinateSequence.toCoordinateArray() |
| Modifier and Type | Method and Description |
|---|---|
CoordinateSequence |
PackedCoordinateSequenceFactory.create(Coordinate[] coordinates) |
CoordinateSequence |
CoordinateArraySequenceFactory.create(Coordinate[] coordinates)
Returns a
CoordinateArraySequence based on the given array (the array is
not copied). |
void |
CoordinateArraySequence.getCoordinate(int index,
Coordinate coord) |
void |
PackedCoordinateSequence.getCoordinate(int i,
Coordinate coord) |
| Constructor and Description |
|---|
CoordinateArraySequence(Coordinate[] coordinates)
Constructs a sequence based on the given array
of
Coordinate s (the
array is not copied). |
CoordinateArraySequence(Coordinate[] coordinates,
int dimension)
Constructs a sequence based on the given array
of
Coordinate s (the
array is not copied). |
Double(Coordinate[] coordinates)
Builds a new packed coordinate sequence out of a coordinate array
|
Double(Coordinate[] coordinates,
int dimension)
Builds a new packed coordinate sequence out of a coordinate array
|
Float(Coordinate[] coordinates,
int dimension)
Constructs a packed coordinate sequence out of a coordinate array
|
| Modifier and Type | Method and Description |
|---|---|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of
Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate
and places the results in the dest coordinate
(which may be the same as the source).
|
| Modifier and Type | Method and Description |
|---|---|
static AffineTransformation |
AffineTransformationFactory.createFromBaseLines(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a maping between two baselines.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate[] src,
Coordinate[] dest)
Creates an AffineTransformation defined by a set of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate dest0)
Creates an AffineTransformation defined by a single control vector.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate dest0,
Coordinate dest1)
Creates an AffineTransformation defined by a pair of control vectors.
|
static AffineTransformation |
AffineTransformationFactory.createFromControlVectors(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Creates a tranformation from a set of three control vectors.
|
abstract Coordinate[] |
GeometryEditor.CoordinateOperation.edit(Coordinate[] coordinates,
Geometry geometry)
Edits the array of
Coordinate s from a Geometry . |
Coordinate |
AffineTransformation.transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate
and places the results in the dest coordinate
(which may be the same as the source).
|
| Constructor and Description |
|---|
AffineTransformation(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a transformation
which maps the given source
points into the given destination points.
|
AffineTransformationBuilder(Coordinate src0,
Coordinate src1,
Coordinate src2,
Coordinate dest0,
Coordinate dest1,
Coordinate dest2)
Constructs a new builder for
the transformation defined by the given
set of control point mappings.
|
| Modifier and Type | Field and Description |
|---|---|
Coordinate |
EdgeIntersection.coord |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
GeometryGraph.getBoundaryPoints() |
Coordinate |
EdgeEnd.getCoordinate() |
Coordinate |
EdgeIntersection.getCoordinate() |
abstract Coordinate |
GraphComponent.getCoordinate() |
Coordinate |
EdgeEndStar.getCoordinate() |
Coordinate |
Node.getCoordinate() |
Coordinate |
Edge.getCoordinate() |
Coordinate |
EdgeRing.getCoordinate(int i) |
Coordinate |
Edge.getCoordinate(int i) |
Coordinate[] |
Edge.getCoordinates() |
Coordinate |
EdgeEnd.getDirectedCoordinate() |
Coordinate |
GeometryGraph.getInvalidPoint() |
| Modifier and Type | Method and Description |
|---|---|
EdgeIntersection |
EdgeIntersectionList.add(Coordinate intPt,
int segmentIndex,
double dist)
Adds an intersection into the list, if it isn't already there.
|
Node |
PlanarGraph.addNode(Coordinate coord) |
Node |
NodeMap.addNode(Coordinate coord)
This method expects that a node has a coordinate value.
|
void |
GeometryGraph.addPoint(Coordinate pt)
Add a point computed externally.
|
boolean |
EdgeRing.containsPoint(Coordinate p)
This method will cause the ring to be computed.
|
Node |
NodeFactory.createNode(Coordinate coord)
The basic node constructor does not allow for incident edges
|
Node |
PlanarGraph.find(Coordinate coord) |
Node |
NodeMap.find(Coordinate coord) |
Edge |
PlanarGraph.findEdge(Coordinate p0,
Coordinate p1)
Returns the edge whose first two coordinates are p0 and p1
|
Edge |
PlanarGraph.findEdgeInSameDirection(Coordinate p0,
Coordinate p1)
Returns the edge which starts at p0 and whose first segment is
parallel to p1
|
boolean |
PlanarGraph.isBoundaryNode(int geomIndex,
Coordinate coord) |
boolean |
EdgeIntersectionList.isIntersection(Coordinate pt)
Tests if the given point is an edge intersection
|
int |
GeometryGraph.locate(Coordinate pt)
Determines the
Location of the given Coordinate
in this geometry. |
static int |
Quadrant.quadrant(Coordinate p0,
Coordinate p1)
Returns the quadrant of a directed line segment from p0 to p1.
|
| Constructor and Description |
|---|
Edge(Coordinate[] pts) |
Edge(Coordinate[] pts,
Label label) |
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1) |
EdgeEnd(Edge edge,
Coordinate p0,
Coordinate p1,
Label label) |
EdgeIntersection(Coordinate coord,
int segmentIndex,
double dist) |
Node(Coordinate coord,
EdgeEndStar edges) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
MonotoneChainEdge.getCoordinates() |
Coordinate |
SegmentIntersector.getProperIntersectionPoint() |
| Modifier and Type | Method and Description |
|---|---|
int[] |
MonotoneChainIndexer.getChainStartIndices(Coordinate[] pts) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
MonotoneChain.getCoordinates()
Return the subsequence of coordinates forming this chain.
|
| Modifier and Type | Method and Description |
|---|---|
static java.util.List |
MonotoneChainBuilder.getChains(Coordinate[] pts) |
static java.util.List |
MonotoneChainBuilder.getChains(Coordinate[] pts,
java.lang.Object context)
Return a list of the
MonotoneChain s
for the given list of coordinates. |
static int[] |
MonotoneChainBuilder.getChainStartIndices(Coordinate[] pts)
Return an array containing lists of start/end indexes of the monotone chains
for the given list of coordinates.
|
| Constructor and Description |
|---|
MonotoneChain(Coordinate[] pts,
int start,
int end,
java.lang.Object context) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
KdNode.getCoordinate()
Returns the location of this node
|
static Coordinate[] |
KdTree.toCoordinates(java.util.Collection kdnodes)
Converts a collection of
KdNode s to an array of Coordinate s. |
static Coordinate[] |
KdTree.toCoordinates(java.util.Collection kdnodes,
boolean includeRepeated)
Converts a collection of
KdNode s
to an array of Coordinate s,
specifying whether repeated nodes should be represented
by multiple coordinates. |
| Modifier and Type | Method and Description |
|---|---|
KdNode |
KdTree.insert(Coordinate p)
Inserts a new point in the kd-tree, with no data.
|
KdNode |
KdTree.insert(Coordinate p,
java.lang.Object data)
Inserts a new point into the kd-tree.
|
| Constructor and Description |
|---|
KdNode(Coordinate p,
java.lang.Object data)
Creates a new KdNode.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
Key.getCentre() |
Coordinate |
Key.getPoint() |
| Modifier and Type | Method and Description |
|---|---|
static java.lang.String |
WKTWriter.toLineString(Coordinate[] coord)
Generates the WKT for a LINESTRING
specified by a
CoordinateSequence . |
static java.lang.String |
WKTWriter.toLineString(Coordinate p0,
Coordinate p1)
Generates the WKT for a LINESTRING
specified by two
Coordinate s. |
static java.lang.String |
WKTWriter.toPoint(Coordinate p0)
Generates the WKT for a POINT
specified by a
Coordinate . |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
LengthIndexedLine.extractPoint(double index)
Computes the
Coordinate for the point
on the line at the given index. |
Coordinate |
LengthIndexedLine.extractPoint(double index,
double offsetDistance)
Computes the
Coordinate for the point
on the line at the given index, offset by the given distance. |
Coordinate |
LocationIndexedLine.extractPoint(LinearLocation index)
Computes the
Coordinate for the point
on the line at the given index. |
Coordinate |
LocationIndexedLine.extractPoint(LinearLocation index,
double offsetDistance)
Computes the
Coordinate for the point
on the line at the given index, offset by the given distance. |
Coordinate |
LinearLocation.getCoordinate(Geometry linearGeom)
Gets the
Coordinate along the
given linear Geometry which is
referenced by this location. |
Coordinate |
LinearGeometryBuilder.getLastCoordinate() |
Coordinate |
LinearIterator.getSegmentEnd()
Gets the second
Coordinate of the current segment. |
Coordinate |
LinearIterator.getSegmentStart()
Gets the first
Coordinate of the current segment. |
static Coordinate |
LinearLocation.pointAlongSegmentByFraction(Coordinate p0,
Coordinate p1,
double frac)
Computes the
Coordinate of a point a given fraction
along the line segment (p0, p1). |
| Modifier and Type | Method and Description |
|---|---|
void |
LinearGeometryBuilder.add(Coordinate pt)
Adds a point to the current line.
|
void |
LinearGeometryBuilder.add(Coordinate pt,
boolean allowRepeatedPoints)
Adds a point to the current line.
|
double |
LengthIndexedLine.indexOf(Coordinate pt)
Computes the minimum index for a point on the line.
|
LinearLocation |
LocationIndexedLine.indexOf(Coordinate pt)
Computes the index for a given point on the line.
|
double |
LengthIndexedLine.indexOfAfter(Coordinate pt,
double minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
LinearLocation |
LocationIndexedLine.indexOfAfter(Coordinate pt,
LinearLocation minIndex)
Finds the index for a point on the line
which is greater than the given index.
|
static Coordinate |
LinearLocation.pointAlongSegmentByFraction(Coordinate p0,
Coordinate p1,
double frac)
Computes the
Coordinate of a point a given fraction
along the line segment (p0, p1). |
double |
LengthIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point.
|
LinearLocation |
LocationIndexedLine.project(Coordinate pt)
Computes the index for the closest point on the line to the given point.
|
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
Vector3D.normalize(Coordinate v) |
Coordinate |
Vector2D.toCoordinate() |
Coordinate |
Vector2D.translate(Coordinate coord) |
| Modifier and Type | Method and Description |
|---|---|
static Vector2D |
Vector2D.create(Coordinate coord)
Creates a vector from a
Coordinate . |
static Vector3D |
Vector3D.create(Coordinate coord)
Creates a vector from a
Coordinate . |
static Vector2D |
Vector2D.create(Coordinate from,
Coordinate to)
Creates a vector with the direction and magnitude
of the difference between the
to and from
Coordinate s. |
static double |
Vector3D.dot(Coordinate v1,
Coordinate v2)
Computes the 3D dot-product of two
Coordinate s. |
static double |
Vector3D.dot(Coordinate A,
Coordinate B,
Coordinate C,
Coordinate D)
Computes the dot product of the 3D vectors AB and CD.
|
static double |
Vector3D.length(Coordinate v) |
static Coordinate |
Vector3D.normalize(Coordinate v) |
double |
Plane3D.orientedDistance(Coordinate p)
Computes the oriented distance from a point to the plane.
|
Coordinate |
Vector2D.translate(Coordinate coord) |
| Constructor and Description |
|---|
Plane3D(Vector3D normal,
Coordinate basePt) |
Vector2D(Coordinate v) |
Vector2D(Coordinate from,
Coordinate to) |
Vector3D(Coordinate v) |
Vector3D(Coordinate from,
Coordinate to) |
| Modifier and Type | Field and Description |
|---|---|
Coordinate |
SegmentNode.coord |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
SegmentNode.getCoordinate()
Gets the
Coordinate giving the location of this node. |
Coordinate |
NodedSegmentString.getCoordinate(int i) |
Coordinate |
SegmentString.getCoordinate(int i) |
Coordinate |
BasicSegmentString.getCoordinate(int i) |
Coordinate[] |
NodedSegmentString.getCoordinates() |
Coordinate[] |
SegmentString.getCoordinates() |
Coordinate[] |
BasicSegmentString.getCoordinates() |
Coordinate |
InteriorIntersectionFinder.getInteriorIntersection()
Gets the computed location of the intersection.
|
Coordinate |
SegmentIntersectionDetector.getIntersection()
Gets the computed location of the intersection.
|
Coordinate[] |
InteriorIntersectionFinder.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
Coordinate[] |
SegmentIntersectionDetector.getIntersectionSegments()
Gets the endpoints of the intersecting segments.
|
Coordinate |
IntersectionAdder.getProperIntersectionPoint() |
Coordinate[] |
SegmentNodeList.getSplitCoordinates()
Gets the list of coordinates for the fully noded segment string,
including all original segment string vertices and vertices
introduced by nodes in this list.
|
| Modifier and Type | Method and Description |
|---|---|
SegmentNode |
SegmentNodeList.add(Coordinate intPt,
int segmentIndex)
Adds an intersection into the list, if it isn't already there.
|
void |
NodableSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
void |
NodedSegmentString.addIntersection(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
SegmentNode |
NodedSegmentString.addIntersectionNode(Coordinate intPt,
int segmentIndex)
Adds an intersection node for a given point and segment to this segment string.
|
static int |
SegmentPointComparator.compare(int octant,
Coordinate p0,
Coordinate p1)
Compares two
Coordinate s for their relative position along a segment
lying in the specified Octant . |
static int |
Octant.octant(Coordinate p0,
Coordinate p1)
Returns the octant of a directed line segment from p0 to p1.
|
| Constructor and Description |
|---|
BasicSegmentString(Coordinate[] pts,
java.lang.Object data)
Creates a new segment string from a list of vertices.
|
NodedSegmentString(Coordinate[] pts,
java.lang.Object data)
Creates a new segment string from a list of vertices.
|
OrientedCoordinateArray(Coordinate[] pts)
Creates a new
OrientedCoordinateArray
for the given Coordinate array. |
SegmentNode(NodedSegmentString segString,
Coordinate coord,
int segmentIndex,
int segmentOctant) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
HotPixel.getCoordinate()
Gets the coordinate this hot pixel is based at.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
HotPixel.intersects(Coordinate p0,
Coordinate p1)
Tests whether the line segment (p0-p1)
intersects this hot pixel.
|
| Constructor and Description |
|---|
HotPixel(Coordinate pt,
double scaleFactor,
LineIntersector li)
Creates a new hot pixel, using a given scale factor.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
IsSimpleOp.getNonSimpleLocation()
Gets a coordinate for the location where the geometry
fails to be simple.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings.
|
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance) |
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines,
as well as rings.
|
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list.
|
Coordinate[] |
BufferInputLineSimplifier.simplify(double distanceTol)
Simplify the input coordinate list.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
OffsetCurveBuilder.getLineCurve(Coordinate[] inputPts,
double distance)
This method handles single points as well as LineStrings.
|
Coordinate[] |
OffsetCurveBuilder.getOffsetCurve(Coordinate[] inputPts,
double distance) |
Coordinate[] |
OffsetCurveBuilder.getRingCurve(Coordinate[] inputPts,
int side,
double distance)
This method handles the degenerate cases of single points and lines,
as well as rings.
|
static Coordinate[] |
BufferInputLineSimplifier.simplify(Coordinate[] inputLine,
double distanceTol)
Simplify the input coordinate list.
|
| Constructor and Description |
|---|
BufferInputLineSimplifier(Coordinate[] inputLine) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
PointPairDistance.getCoordinate(int i) |
Coordinate[] |
PointPairDistance.getCoordinates() |
Coordinate |
BufferDistanceValidator.getErrorLocation() |
Coordinate |
BufferResultValidator.getErrorLocation() |
| Modifier and Type | Method and Description |
|---|---|
static void |
DistanceToPointFinder.computeDistance(Geometry geom,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(LineSegment segment,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(LineString line,
Coordinate pt,
PointPairDistance ptDist) |
static void |
DistanceToPointFinder.computeDistance(Polygon poly,
Coordinate pt,
PointPairDistance ptDist) |
void |
BufferCurveMaximumDistanceFinder.MaxPointDistanceFilter.filter(Coordinate pt) |
void |
PointPairDistance.initialize(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMaximum(Coordinate p0,
Coordinate p1) |
void |
PointPairDistance.setMinimum(Coordinate p0,
Coordinate p1) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
DistanceOp.closestPoints()
Deprecated.
renamed to nearestPoints
|
static Coordinate[] |
DistanceOp.closestPoints(Geometry g0,
Geometry g1)
Deprecated.
renamed to nearestPoints
|
Coordinate |
GeometryLocation.getCoordinate()
Returns the
Coordinate of this location. |
Coordinate |
FacetSequence.getCoordinate(int index) |
Coordinate[] |
DistanceOp.nearestPoints()
Report the coordinates of the nearest points in the input geometries.
|
static Coordinate[] |
DistanceOp.nearestPoints(Geometry g0,
Geometry g1)
Compute the the nearest points of two geometries.
|
| Constructor and Description |
|---|
GeometryLocation(Geometry component,
Coordinate pt)
Constructs a GeometryLocation specifying a point inside an area geometry.
|
GeometryLocation(Geometry component,
int segIndex,
Coordinate pt)
Constructs a GeometryLocation specifying a point on a geometry, as well as the
segment that the point is on
(or
GeometryLocation.INSIDE_AREA if the point is not on a segment). |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
AxisPlaneCoordinateSequence.getCoordinate(int i) |
Coordinate |
AxisPlaneCoordinateSequence.getCoordinateCopy(int i) |
Coordinate[] |
Distance3DOp.nearestPoints()
Report the coordinates of the nearest points in the input geometries.
|
static Coordinate[] |
Distance3DOp.nearestPoints(Geometry g0,
Geometry g1)
Compute the the nearest points of two geometries.
|
Coordinate[] |
AxisPlaneCoordinateSequence.toCoordinateArray() |
| Modifier and Type | Method and Description |
|---|---|
void |
AxisPlaneCoordinateSequence.getCoordinate(int index,
Coordinate coord) |
boolean |
PlanarPolygon3D.intersects(Coordinate intPt) |
boolean |
PlanarPolygon3D.intersects(Coordinate pt,
LineString ring) |
| Constructor and Description |
|---|
LineMergeDirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a LineMergeDirectedEdge connecting the
from node to the
to node. |
| Modifier and Type | Method and Description |
|---|---|
boolean |
PolygonBuilder.containsPoint(Coordinate p)
Checks the current set of shells (with their associated holes) to
see if any of them contain the point.
|
Node |
OverlayNodeFactory.createNode(Coordinate coord) |
boolean |
OverlayOp.isCoveredByA(Coordinate coord)
Tests if an L edge should be included in the result or not.
|
boolean |
OverlayOp.isCoveredByLA(Coordinate coord)
Tests if a point node should be included in the result or not.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString
to the given set of snap vertices.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
LineStringSnapper.snapTo(Coordinate[] snapPts)
Snaps the vertices and segments of the source LineString
to the given set of snap vertices.
|
| Constructor and Description |
|---|
LineStringSnapper(Coordinate[] srcPts,
double snapTolerance)
Creates a new snapper using the given points
as source points to be snapped.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
OverlayResultValidator.getInvalidLocation() |
| Modifier and Type | Method and Description |
|---|---|
int |
FuzzyPointLocator.getLocation(Coordinate pt) |
| Modifier and Type | Method and Description |
|---|---|
Node |
RelateNodeFactory.createNode(Coordinate coord) |
| Constructor and Description |
|---|
RelateNode(Coordinate coord,
EdgeEndStar edges) |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords
that is NOT a node in the edge for the list of searchCoords
|
Coordinate |
TopologyValidationError.getCoordinate()
Returns the location of this error (on the
Geometry containing the error). |
Coordinate |
RepeatedPointTester.getCoordinate() |
Coordinate |
ConnectedInteriorTester.getCoordinate() |
Coordinate |
ConsistentAreaTester.getInvalidPoint() |
Coordinate |
SweeplineNestedRingTester.getNestedPoint() |
Coordinate |
IndexedNestedRingTester.getNestedPoint() |
Coordinate |
QuadtreeNestedRingTester.getNestedPoint() |
Coordinate |
SimpleNestedRingTester.getNestedPoint() |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
ConnectedInteriorTester.findDifferentPoint(Coordinate[] coord,
Coordinate pt) |
static Coordinate |
IsValidOp.findPtNotNode(Coordinate[] testCoords,
LinearRing searchRing,
GeometryGraph graph)
Find a point from the list of testCoords
that is NOT a node in the edge for the list of searchCoords
|
boolean |
RepeatedPointTester.hasRepeatedPoint(Coordinate[] coord) |
static boolean |
IsValidOp.isValid(Coordinate coord)
Checks whether a coordinate is valid for processing.
|
| Constructor and Description |
|---|
TopologyValidationError(int errorType,
Coordinate pt)
Creates a validation error with the given type and location
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
DirectedEdgeStar.getCoordinate()
Returns the coordinate for the node at wich this star is based
|
Coordinate |
Node.getCoordinate()
Returns the location of this Node.
|
Coordinate |
DirectedEdge.getCoordinate()
Returns the coordinate of the from-node.
|
Coordinate |
DirectedEdge.getDirectionPt()
Returns a point to which an imaginary line is drawn from the from-node to
specify this DirectedEdge's orientation.
|
| Modifier and Type | Method and Description |
|---|---|
Node |
NodeMap.find(Coordinate coord)
Returns the Node at the given location, or null if no Node was there.
|
Node |
PlanarGraph.findNode(Coordinate pt)
|
Node |
NodeMap.remove(Coordinate pt)
Removes the Node at the given location, and returns it (or null if no Node was there).
|
| Constructor and Description |
|---|
DirectedEdge(Node from,
Node to,
Coordinate directionPt,
boolean edgeDirection)
Constructs a DirectedEdge connecting the
from node to the
to node. |
Node(Coordinate pt)
Constructs a Node with the given location.
|
Node(Coordinate pt,
DirectedEdgeStar deStar)
Constructs a Node with the given location and collection of outgoing DirectedEdges.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
Coordinate |
CommonBitsRemover.getCommonCoordinate()
The common bits of the Coordinates in the supplied Geometries.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate[] |
PrecisionReducerCoordinateOperation.edit(Coordinate[] coordinates,
Geometry geom) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
GeometricShapeBuilder.getCentre() |
| Modifier and Type | Method and Description |
|---|---|
void |
KochSnowflakeBuilder.addSide(int level,
Coordinate p0,
Coordinate p1) |
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment
|
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear
as edges in a constrained Delaunay triangulation.
|
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of
the situation.
|
Coordinate |
ConstraintEnforcementException.getCoordinate()
Gets the approximate location of this error.
|
Coordinate |
Segment.getEnd()
Gets the end coordinate of the segment
|
Coordinate |
SplitSegment.getSplitPoint() |
Coordinate |
Segment.getStart()
Gets the start coordinate of the segment
|
Coordinate |
Segment.intersection(Segment s)
Computes the intersection point between this segment and another one.
|
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment
|
| Modifier and Type | Method and Description |
|---|---|
ConstraintVertex |
ConstraintVertexFactory.createVertex(Coordinate p,
Segment constraintSeg) |
Coordinate |
MidpointSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Gets the midpoint of the split segment
|
Coordinate |
ConstraintSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
Finds a point at which to split an encroached segment to allow the original segment to appear
as edges in a constrained Delaunay triangulation.
|
Coordinate |
NonEncroachingSplitPointFinder.findSplitPoint(Segment seg,
Coordinate encroachPt)
A basic strategy for finding split points when nothing extra is known about the geometry of
the situation.
|
void |
ConformingDelaunayTriangulator.insertSite(Coordinate p)
Inserts a site into the triangulation, maintaining the conformal Delaunay property.
|
static Coordinate |
NonEncroachingSplitPointFinder.projectedSplitPoint(Segment seg,
Coordinate encroachPt)
Computes a split point which is the projection of the encroaching point on the segment
|
void |
SplitSegment.splitAt(Coordinate pt) |
void |
SplitSegment.splitAt(double length,
Coordinate endPt) |
static CoordinateList |
DelaunayTriangulationBuilder.unique(Coordinate[] coords) |
| Constructor and Description |
|---|
ConstraintEnforcementException(java.lang.String msg,
Coordinate pt)
Creates a new instance with a given message and approximate location.
|
ConstraintVertex(Coordinate p)
Creates a new constraint vertex
|
Segment(Coordinate p0,
Coordinate p1)
Creates a new instance for the given points.
|
Segment(Coordinate p0,
Coordinate p1,
java.lang.Object data)
Creates a new instance for the given points, with associated external data.
|
| Modifier and Type | Method and Description |
|---|---|
Coordinate |
Vertex.getCoordinate() |
Coordinate |
QuadEdgeTriangle.getCoordinate(int i) |
Coordinate[] |
QuadEdgeTriangle.getCoordinates() |
| Modifier and Type | Method and Description |
|---|---|
boolean |
QuadEdgeTriangle.contains(Coordinate pt) |
static boolean |
QuadEdgeTriangle.contains(QuadEdge[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3
QuadEdge es. |
static boolean |
QuadEdgeTriangle.contains(Vertex[] tri,
Coordinate pt)
Tests whether the point pt is contained in the triangle defined by 3
Vertex es. |
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate p0,
Coordinate p1)
Computes the interpolated Z-value for a point p lying on the segment p0-p1
|
static double |
Vertex.interpolateZ(Coordinate p,
Coordinate v0,
Coordinate v1,
Coordinate v2)
Interpolates the Z-value (height) of a point enclosed in a triangle
whose vertices all have Z values.
|
static boolean |
TrianglePredicate.isInCircleCC(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Computes the inCircle test using distance from the circumcentre.
|
static boolean |
TrianglePredicate.isInCircleDDFast(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p) |
static boolean |
TrianglePredicate.isInCircleDDNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p) |
static boolean |
TrianglePredicate.isInCircleDDSlow(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleNonRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleNormalized(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
static boolean |
TrianglePredicate.isInCircleRobust(Coordinate a,
Coordinate b,
Coordinate c,
Coordinate p)
Tests if a point is inside the circle defined by
the triangle with vertices a, b, c (oriented counter-clockwise).
|
boolean |
QuadEdgeSubdivision.isOnEdge(QuadEdge e,
Coordinate p)
Tests whether a
Coordinate lies on a QuadEdge , up to a
tolerance determined by the subdivision tolerance. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p)
Finds a quadedge of a triangle containing a location
specified by a
Coordinate , if one exists. |
QuadEdge |
QuadEdgeSubdivision.locate(Coordinate p0,
Coordinate p1)
Locates the edge between the given vertices, if it exists in the
subdivision.
|
static DD |
TrianglePredicate.triAreaDDFast(Coordinate a,
Coordinate b,
Coordinate c) |
| Constructor and Description |
|---|
Vertex(Coordinate _p) |
| Modifier and Type | Method and Description |
|---|---|
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinate s. |
Coordinate[] |
CoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
Coordinate[] |
UniqueCoordinateArrayFilter.getCoordinates()
Returns the gathered
Coordinate s. |
| Modifier and Type | Method and Description |
|---|---|
static void |
Debug.breakIfEqual(Coordinate p0,
Coordinate p1,
double tolerance) |
static boolean |
Debug.equals(Coordinate c1,
Coordinate c2,
double tolerance) |
void |
CoordinateArrayFilter.filter(Coordinate coord) |
void |
UniqueCoordinateArrayFilter.filter(Coordinate coord) |
void |
CoordinateCountFilter.filter(Coordinate coord) |
static Coordinate[] |
UniqueCoordinateArrayFilter.filterCoordinates(Coordinate[] coords)
Convenience method which allows running the filter over an array of
Coordinate s. |
static boolean |
Debug.hasSegment(Geometry geom,
Coordinate p0,
Coordinate p1) |
void |
GeometricShapeFactory.setBase(Coordinate base)
Sets the location of the shape by specifying the base coordinate
(which in most cases is the
lower left point of the envelope containing the shape).
|
void |
GeometricShapeFactory.setCentre(Coordinate centre)
Sets the location of the shape by specifying the centre of
the shape's bounding box
|
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1) |
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2) |
static LineString |
Debug.toLine(Coordinate p0,
Coordinate p1,
Coordinate p2,
Coordinate p3) |
| Constructor and Description |
|---|
PointWithAttr(Coordinate coordinate,
PrecisionModel precisionModel,
int SRID) |


4
1 Listen, sons, to a father's instruction,
and pay attention so you will know what understanding is.
2 I am giving you good instructions;
do not forsake my teaching.
3 When I was a son of my father,
the tender and only child of my mother,
4 he taught me and said to me,
"Let your heart hold fast to my words;
keep my commands and live.
5 Acquire wisdom and understanding;
do not forget and do not reject the words of my mouth;
6 do not abandon wisdom and she will watch over you;
love her and she will keep you safe.
7 Wisdom is the most important thing, so acquire wisdom
and spend all you own so you can get understanding.
8 Cherish wisdom and she will exalt you;
she will honor you when you embrace her.
9 She will put a wreath of honor on your head;
she will give you a beautiful crown."
10 Listen, my son, and pay attention to my words,
and you will have many years in your life.
11 I direct you in the way of wisdom;
I lead you down straight paths.
12 When you walk, no one will stand in your way
and if you run, you will not stumble.
13 Hold on to discipline, do not let it go;
guard it, for it is your life.
14 Do not follow the path of the wicked
and do not go along the way of those who do evil.
15 Avoid it, do not go on it;
turn away from it and go another way.
16 For they cannot sleep until they do evil
and they are robbed of sleep until they cause someone to stumble.
17 For they eat the bread of wickedness
and drink the wine of violence.
18 But the path of the one who does right is like the first light that grows brighter;
it shines more and more until the fullness of the day comes.
19 The way of the wicked is like darkness—
they do not know what it is they stumble over.
20 My son, pay attention to my words;
listen to my sayings.
21 Do not let them turn away from your eyes;
keep them in your heart.
22 For my words are life to those who find them
and health to their whole body.
23 Keep your heart safe and guard it with all diligence,
for from it flow the springs of life.
24 Put crooked speech away from you
and put corrupt talk far from you.
25 Let your eyes look straight ahead
and fix your gaze straight before you.
26 Make a level path for your foot;
then all your ways will be secure.
27 Do not turn aside to the right or to the left;
turn your foot away from evil.


Welcome to annalist.net
Annalist demo server (v0.1.10) on HTTP port 8000, or via reverse proxy on HTTP port 80.
Feedback
Please feel free to try using the demonstrator at demo.annalist.net, and send any feedback to the Annalist discussion group or the issue tracker for the Annalist GitHub project.
There is some browseable data there. The CruisingLog data is a snapshot of some real Annalist application data I'm working on.
If you log in using Google+ credentials, you can create a new Annalist data collection and play with it, but please be aware this is a development and demonstration platform and data may be reset at any time.
Resources
Source code and documentation is available from the Annalist GitHub repository (github.com/gklyne/annalist).
The raw data that underlies the Annalist site can be viewed at annalist.net/annalist_sitedata/. Subdirectory _annalist_site contains site-wide configuration data and definitions; and subdirectory c contains user collection data.
Other resources on this server
Demonstration videos
-
Initializing Annalist site data
(1m47s) - shows the procedure for first-time initialization of new Annalist site data using the
annalist-manager
utility. -
Log in and and create first collection
(3m32s) - steps through an initial login using the
admin
user created previously, create a new collection and create permissions for a Google-authenticated user to modify that collection. - Initial entry of data in a new collection (3m32s) - covers adding data to a new collection, and adding data record fields beyond the initial default fields.
- Configure types and record views in a data collection (3m46s) - customize a collectionto reflect the data it contains through the addition of record types and record views.
- Configure list view and default display (3m51s) - customize collection content listings and defaults to simplify the entry of new data.
Scripts for the above demonstration sequences, to allow the operations shown to be performed locally, can be found at github.com/gklyne/annalist/blob/master/documents/demo-script.md.
There is also the Original demonstration screencast: 6 minute video showing Annalist used to create and start populating a simple catalogue of musical instruments.
Software download
The easiest way to obftain the software is generally to install it from PyPI using the Python pip
utility. See the Annalist getting started page.
-
Annalist-0.1.10:
Downloadable software installation kit. Needs Python 2.7,
virtualenv
andpip
. Install usingpip
into a newly created Python virtual environment. - Annalist-0.1.8a (older release).
- Annalist-0.1.8 (older release).
- Annalist-0.1.6 (older release).
- Annalist-0.1.4 (older release).


eta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
545 W. Universe St. Chicago, Il 60613<PHONE_NUMBER> iamtheuniverse.com
Objective: Seeking a rewarding and challenging position where I may utilize my skills and experience for both company and personal growth in a dev environment.
Experience
Microtrain Fullstack Dev Student
Current-March 18, 2020
Languages Known:
Uber
2015-2018
Professional Driver
Verizon Wireless
2014-2016
Customer Service Advocate


These parameters apply to every node inside the
cluster.
On this page, one may change the global cluster parameters. Please see the full documentation for the different available
parameters. The necessity to reboot after a change depends on the parameter.


Girl Develop It is here to provide affordable and accessible programs to learn software through mentorship and hands-on instruction.
Some "rules"
We are here for you!
Every question is important.
Help each other.
Have fun.
Welcome!
Tell us about yourself.
What's your name?
What's your favorite thing you've ever made?
What is a database?
A set of related data and the way it is organized!
Photo credit: Buzzfeed
What is a database?
A collection of tables, schemas, queries, reports, views, and other objects (it’s not just tables of data!) often organized in a way that supports
processes or reflects real life in order to facilitate business or functions.
What is a database - what are those things?!
A collection of tables, schemas, queries, views…
Table = collection of related data arranged in columns and rows.
Schema = logical grouping of objects (tables, etc.), often in a functional way.
Query = request for information from a database.
View = result of a stored query.
Levels of the Database
Photo credit: W3 Schools
Data Independence
Changes made at one level do not affect any other level.
Independence hides the details of the storage structure from user applications.
Physical independence = ability to modify the physical schema without causing application programs to be rewritten.
Logical independence = ability to modify the logical schema without causing application programs to be rewritten.


Application
, in order to initialize Stetho
inspection and set up access to this instance via the singleton pattern.Transform
instances in the local
database, using Room annotations.TransformDB
Room/SQLite database.DELETE
of one or more Image
instances from the
local database.INSERT
of one or more Image
instances into the
local database.SELECT
of all Transform
instances (sorted in
descending date order) from the local database.TransformOperation.transform(Bitmap, View)
method and the TransformOperation.getLayout()
method.


number:
date:
datetime-local:
range:
color:
radio 1:
radio 2:
https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input


{% load static %}
Errors scattering matrix help:
The page represents a correlation matrix between ATLAS production Requests/Tasks and Regions/Queues.
The displayed tasks are in running or submitting states only. Paused tasks are removed.
On the main page the first column shows all the active production Requests and the first row shows all the Regions participating in production. The second column displays the number of Tasks in each Request with various job execution success rates (>80%, <80%, <50%). The second row displays the number of Queues in each Region with various job execution success rates (>80%, <80%, <50%). The cells of the table show the production job success rate, as well as number of finished and failed jobs for each Request vs. Region combination/intersection.
Legend on the upper right corner clarifies the color codding of the cells and numbers used in the page. Lighter colors indicate cells with low job statistics (number of jobs < 10).
Rows are ordered by average success rate, with Requests having the highest failing rate on top.
Each Request (first column) has a sign in front. Clicking on the Request number on the other hand will open the PanDA page of that Request. Clicking it will open a similar correlation matrix page with all the Tasks belonging to that Request. Clicking on a Grafana icon leads to job monitoring dashboard for given request with more detailed information.
Each Region (first row) has a sign under the Region name. Clicking it will open a similar correlation matrix page with all the Queues belonging to that Region. Clicking on the Region name on the other hand will open the panda page of that Region.
The default time window for the overall job statistics at each cell is 8 hours. But the page has a Time window
menu with other time window options (24 hours, 7 days). You can also manually modify the time window to any other value in the page URL.
The page has various display or filtering options through the following buttons:
Switch to the queues viewbutton allows you to display all the queues at once.
Exclude scoutsbutton will exclude the scouting jobs from the statistics, so basically the matrix will skip the Requests/Tasks which are still running scouting jobs.
Hide low statistics cellsbutton will omit the cells with <100 statistics, so basically it will condense the matrix, showing only the cells with higher contributions to production.
On the request page, there is a Grafana icon on the top left (next to the request number). This leads to job monitoring dashboard for given request with more detailed information. There, one can also select specific tasks of the request.


Detect all Japanese
Translate to English
Identify one bubble
Brush
Save
Export .png
About
Help
BUBBLE
Line height:
Font size:
Font:
Wild Words
Death Rattle
Akbar
Obelix Pro
Laffayette Comic Pro
From Where You Are
Advanced...
Rotate:
Stroke width:
Duplicate bubble
Rasterize text
Delete:
INSTRUCTIONS
Click in one corner of the bubble, then on the opposite (diagonal) corner.
BRUSH
Color:
White
Black
Erase
Size:
FONT GUIDE
Dialogue...
Shouts!
Handwriting =)
Emphasis
Thoughts?
Anything~
LAYERS
[1] Show text layer
[2] Show edit layer


Money
Manager
Set daily and monthly spending limits
You can set a limit on how much you want to spend everyday and/or every month so when you cross that limit, Money Manager will let you know that you have exceeded your limit.
Review your daily, monthly and yearly activity
Money Manager lets you review your daily, monthly, yearly and yesterday's expenses. Moreover, you can also view your expenses for any date you want.
Simple. Straightforward.
Money Management.
Introducing Money Manager by KinitoApps, A Lightweight Android App for managing your expenses.
Present your product in beautiful way with us
The Apple Watch – is it any good, and should you buy one? Well, it’s a distinctive piece of tech that at first can be hard to get your head around, or even to quite know what it does. In short, it’s a watch that sends notifications and other information from your iPhone to your wrist and lets you send stuff back the other way, whether that’s a text message, a phone call or a simple way to call an Uber.