Added calculation of the distance between a line and a point

Darya177777 · Darya177777 · commit 1364bd7eea49 · 2023-08-04T16:40:28.000+07:00
diff --git a/doc/operators.sgm b/doc/operators.sgm
@@ -331,7 +331,8 @@
                 a non-boolean operator returning the distance between two
                 objects in radians. Currently,
                 <application>pgSphere</application> supports only distances
-                between points, circles, and between point and circle. If the
+                between points, circles, between point and circle, and
+                between point and line. If the
                 objects are overlapping, the distance operator returns zero
                 (0.0).
             </para>
@@ -343,6 +344,17 @@
 <![CDATA[ dist]]>
 <![CDATA[------]]>
 <![CDATA[ 16]]>
+<![CDATA[(1 row)]]>
+              </programlisting>
+            </example>
+            <example>
+              <title>Distance between point and line</title>
+              <programlisting>
+<![CDATA[sql> SELECT 180 * (sline '( 0d, 0d, 0d, XYZ ), 40d ' <-> spoint '( 0d, 90d )')]]>
+<![CDATA[        / pi() AS dist ;]]>
+<![CDATA[ dist]]>
+<![CDATA[------]]>
+<![CDATA[ 90]]>
 <![CDATA[(1 row)]]>
               </programlisting>
             </example>
diff --git a/expected/init_test.out.in b/expected/init_test.out.in
@@ -24,12 +24,12 @@ psql:pg_sphere.test.sql:159: NOTICE:  argument type spath is only a shell
 psql:pg_sphere.test.sql:178: NOTICE:  type "sbox" is not yet defined
 DETAIL:  Creating a shell type definition.
 psql:pg_sphere.test.sql:185: NOTICE:  argument type sbox is only a shell
-psql:pg_sphere.test.sql:8540: NOTICE:  type "spherekey" is not yet defined
+psql:pg_sphere.test.sql:8590: NOTICE:  type "spherekey" is not yet defined
 DETAIL:  Creating a shell type definition.
-psql:pg_sphere.test.sql:8547: NOTICE:  argument type spherekey is only a shell
-psql:pg_sphere.test.sql:8561: NOTICE:  type "pointkey" is not yet defined
+psql:pg_sphere.test.sql:8597: NOTICE:  argument type spherekey is only a shell
+psql:pg_sphere.test.sql:8611: NOTICE:  type "pointkey" is not yet defined
 DETAIL:  Creating a shell type definition.
-psql:pg_sphere.test.sql:8568: NOTICE:  argument type pointkey is only a shell
-psql:pg_sphere.test.sql:8574: NOTICE:  argument type pointkey is only a shell
-psql:pg_sphere.test.sql:8580: NOTICE:  argument type pointkey is only a shell
-psql:pg_sphere.test.sql:8586: NOTICE:  argument type pointkey is only a shell
+psql:pg_sphere.test.sql:8618: NOTICE:  argument type pointkey is only a shell
+psql:pg_sphere.test.sql:8624: NOTICE:  argument type pointkey is only a shell
+psql:pg_sphere.test.sql:8630: NOTICE:  argument type pointkey is only a shell
+psql:pg_sphere.test.sql:8636: NOTICE:  argument type pointkey is only a shell
diff --git a/expected/init_test_healpix.out.in b/expected/init_test_healpix.out.in
@@ -1,2 +1,2 @@
-psql:pg_sphere.test.sql:9153: NOTICE:  return type smoc is only a shell
-psql:pg_sphere.test.sql:9159: NOTICE:  argument type smoc is only a shell
+psql:pg_sphere.test.sql:9203: NOTICE:  return type smoc is only a shell
+psql:pg_sphere.test.sql:9209: NOTICE:  argument type smoc is only a shell
diff --git a/expected/line.out b/expected/line.out
@@ -134,4 +134,35 @@ SELECT sline ( spoint '(0,   0d)', spoint '(0.000001d, 0d)' )   #
  f
 (1 row)
 
-       
+-- checking the distance between a line and a point
+SELECT round( CAST(sline '( 90d, 0d, 0d, XYZ ), 40d ' <-> spoint '( 0d, 90d )' as numeric), 14);
+      round       
+------------------
+ 0.87266462599717
+(1 row)
+
+SELECT round( CAST(sline '( 90d, 0d, 0d, XYZ ), 40d ' <-> spoint '( 0d, 90d )' as numeric), 14)   =
+       round( CAST(spoint '( 0d, 90d )' <-> sline '( 90d, 0d, 0d, XYZ ), 40d ' as numeric), 14);
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 0d ' <-> spoint '( 0d, 90d )' as numeric), 14);
+      round       
+------------------
+ 1.57079632679490
+(1 row)
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 0d ' <-> spoint '( 0d, 0d )' as numeric), 14);
+      round       
+------------------
+ 0.00000000000000
+(1 row)
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 30d ' <-> spoint '( 0d, 30d )' as numeric), 14);
+      round       
+------------------
+ 0.52359877559830
+(1 row)
+
diff --git a/pgs_line.sql.in b/pgs_line.sql.in
@@ -593,3 +593,53 @@ COMMENT ON FUNCTION scircle_contains_line_com_neg(sline, scircle) IS
   'returns true if spherical circle does not contain spherical line';
 
 
+--
+-- distance between line and point
+--
+
+CREATE FUNCTION dist(sline, spoint)
+   RETURNS FLOAT8
+   AS 'MODULE_PATHNAME', 'sphereline_point_distance'
+   LANGUAGE 'c'
+   IMMUTABLE STRICT;
+
+COMMENT ON FUNCTION dist(sline, spoint) IS
+  'returns the distance between spherical line and spherical point';
+
+
+CREATE OPERATOR  <-> (
+   LEFTARG    = sline,
+   RIGHTARG   = spoint,
+   COMMUTATOR = '<->',
+   PROCEDURE  = dist
+);
+
+COMMENT ON OPERATOR <-> (sline, spoint) IS
+  'returns the distance between spherical line and spherical point';
+
+
+
+--
+-- distance between point and line
+--
+
+CREATE FUNCTION dist(spoint, sline)
+   RETURNS FLOAT8
+   AS 'MODULE_PATHNAME', 'sphereline_point_distance_com'
+   LANGUAGE 'c'
+   IMMUTABLE STRICT;
+
+COMMENT ON FUNCTION dist(spoint, sline) IS
+  'returns the distance between spherical line and spherical point';
+
+
+CREATE OPERATOR  <-> (
+   LEFTARG    = spoint,
+   RIGHTARG   = sline,
+   COMMUTATOR = '<->',
+   PROCEDURE  = dist
+);
+
+COMMENT ON OPERATOR <-> (spoint, sline) IS
+  'returns the distance between spherical line and spherical point';
+
diff --git a/sql/line.sql b/sql/line.sql
@@ -66,4 +66,18 @@ SELECT sline ( spoint '(0,   0d)', spoint '(0.000001d, 0d)' )   #
 
 SELECT sline ( spoint '(0,   0d)', spoint '(0.000001d, 0d)' )   #
        sline ( spoint '(0.000001d,  0d)', spoint '(0.000001d, 0.0000005d)' ) ;
-       
+
+
+-- checking the distance between a line and a point
+
+
+SELECT round( CAST(sline '( 90d, 0d, 0d, XYZ ), 40d ' <-> spoint '( 0d, 90d )' as numeric), 14);
+
+SELECT round( CAST(sline '( 90d, 0d, 0d, XYZ ), 40d ' <-> spoint '( 0d, 90d )' as numeric), 14)   =
+       round( CAST(spoint '( 0d, 90d )' <-> sline '( 90d, 0d, 0d, XYZ ), 40d ' as numeric), 14);
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 0d ' <-> spoint '( 0d, 90d )' as numeric), 14);
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 0d ' <-> spoint '( 0d, 0d )' as numeric), 14);
+
+SELECT round( CAST(sline '( 0d, 0d, 0d, XYZ ), 30d ' <-> spoint '( 0d, 30d )' as numeric), 14);
diff --git a/src/line.c b/src/line.c
@@ -33,6 +33,8 @@ PG_FUNCTION_INFO_V1(sphereline_overlap_neg);
 PG_FUNCTION_INFO_V1(spheretrans_from_line);
 PG_FUNCTION_INFO_V1(spheretrans_line);
 PG_FUNCTION_INFO_V1(spheretrans_line_inverse);
+PG_FUNCTION_INFO_V1(sphereline_point_distance);
+PG_FUNCTION_INFO_V1(sphereline_point_distance_com);
 
 /*
  * Swaps the beginning and ending of the line.
@@ -642,6 +644,59 @@ sline_center(SPoint *c, const SLine *sl)
 	euler_spoint_trans(c, &p, &se);
 }
 
+float8 sline_point_dist(const SLine *sl, const SPoint *p)
+{
+	Vector3D	v_beg;
+	Vector3D	v_end;
+	Vector3D	v;
+	Vector3D	normal1;
+	Vector3D	normal2;
+	Vector3D	line;
+	Vector3D	first_p;
+	float8		norma;
+	SPoint		fp;
+	SPoint		sp;
+
+	if (spoint_at_sline(p, sl))
+	{
+		return 0.0;
+	}
+
+	sline_vector_begin(&v_beg, sl);
+	sline_vector_end(&v_end, sl);
+	spoint_vector3d(&v, p);
+
+	/* normal1 to the plane passing through the line and the center of the sphere */
+	vector3d_cross(&normal1, &v_beg, &v_end);
+	if (vector3d_eq(&normal1, &v))
+	{
+		return PIH;
+	}
+
+	/* normal2 to the plane perpendicular to the given line. */
+	vector3d_cross(&normal2, &normal1, &v);
+	vector3d_cross(&line, &normal2, &normal1);
+	norma = sqrt(line.x * line.x + line.y * line.y + line.z * line.z);
+
+	first_p.x = line.x / norma;
+	first_p.y = line.y / norma;
+	first_p.z = line.z / norma;
+	vector3d_spoint(&fp, &first_p);
+
+	if (spoint_at_sline(&fp, sl))
+	{
+		return spoint_dist(&fp, p);
+	}
+
+	vector3d_spoint(&fp, &v_beg);
+	vector3d_spoint(&sp, &v_end);
+	if (FPle(spoint_dist(p, &fp), spoint_dist(p, &sp)))
+	{
+		return spoint_dist(p, &fp);
+	}
+	return spoint_dist(p, &sp);
+}
+
 Datum
 sphereline_in(PG_FUNCTION_ARGS)
 {
@@ -1051,3 +1106,20 @@ spheretrans_from_line(PG_FUNCTION_ARGS)
 	sphereline_to_euler(e, l);
 	PG_RETURN_POINTER(e);
 }
+
+Datum
+sphereline_point_distance(PG_FUNCTION_ARGS)
+{
+	SLine	   *s = (SLine *) PG_GETARG_POINTER(0);
+	SPoint	   *p = (SPoint *) PG_GETARG_POINTER(1);
+	PG_RETURN_FLOAT8(sline_point_dist(s, p));
+}
+
+Datum
+sphereline_point_distance_com(PG_FUNCTION_ARGS)
+{
+	SPoint	   *p = (SPoint *) PG_GETARG_POINTER(0);
+	SLine	   *s = (SLine *) PG_GETARG_POINTER(1);
+	PG_RETURN_FLOAT8(sline_point_dist(s, p));
+}
+
diff --git a/src/line.h b/src/line.h
@@ -129,6 +129,11 @@ void	euler_sline_trans(SLine *out, const SLine *in, const SEuler *se);
  */
 void	sline_center(SPoint *c, const SLine *sl);
 
+/*
+ * Calculates the distance between a line 'sl' and a point 'p'
+ */
+float8	sline_point_dist(const SLine *sl, const SPoint *p);
+
 /*
  * The input function for spherical line.
  */
@@ -290,4 +295,14 @@ Datum	spheretrans_line(PG_FUNCTION_ARGS);
  */
 Datum	spheretrans_line_inverse(PG_FUNCTION_ARGS);
 
+/*
+ * Returns the distance between a line and a point.
+ */
+Datum	sphereline_point_distance(PG_FUNCTION_ARGS);
+
+/*
+ * Returns the distance between a point and a line.
+ */
+Datum	sphereline_point_distance_com(PG_FUNCTION_ARGS);
+
 #endif
