开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
spatial.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：42k
源码类别：

MySQL数据库

开发平台：

Visual C++

spatial.cpp：源码内容
  1. /* Copyright (C) 2004 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include "mysql_priv.h"
  19. #ifdef HAVE_SPATIAL
  21. #define MAX_DIGITS_IN_DOUBLE 16
  23. /***************************** Gis_class_info *******************************/
  25. Geometry::Class_info *Geometry::ci_collection[Geometry::wkb_end+1]=
  26. {
  27.   NULL, NULL, NULL, NULL, NULL, NULL, NULL
  28. };
  30. static Geometry::Class_info **ci_collection_end=
  31.                                 Geometry::ci_collection+Geometry::wkb_end + 1;
  33. Geometry::Class_info::Class_info(const char *name, int type_id,
  34.  void(*create_func)(void *)):
  35.   m_name(name, strlen(name)), m_type_id(type_id), m_create_func(create_func)
  36. {
  37.   ci_collection[type_id]= this;
  38. }
  40. static void create_point(void *buffer)
  41. {
  42.   new(buffer) Gis_point;
  43. }
  45. static void create_linestring(void *buffer)
  46. {
  47.   new(buffer) Gis_line_string;
  48. }
  50. static void create_polygon(void *buffer)
  51. {
  52.   new(buffer) Gis_polygon;
  53. }
  55. static void create_multipoint(void *buffer)
  56. {
  57.   new(buffer) Gis_multi_point;
  58. }
  60. static void create_multipolygon(void *buffer)
  61. {
  62.   new(buffer) Gis_multi_polygon;
  63. }
  65. static void create_multilinestring(void *buffer)
  66. {
  67.   new(buffer) Gis_multi_line_string;
  68. }
  70. static void create_geometrycollection(void *buffer)
  71. {
  72.   new(buffer) Gis_geometry_collection;
  73. }
  77. static Geometry::Class_info point_class("POINT",
  78. Geometry::wkb_point, create_point);
  80. static Geometry::Class_info linestring_class("LINESTRING",
  81.      Geometry::wkb_linestring,
  82.      create_linestring);
  83. static Geometry::Class_info polygon_class("POLYGON",
  84.       Geometry::wkb_polygon,
  85.       create_polygon);
  86. static Geometry::Class_info multipoint_class("MULTIPOINT",
  87.  Geometry::wkb_multipoint,
  88.  create_multipoint);
  89. static Geometry::Class_info 
  90. multilinestring_class("MULTILINESTRING",
  91.       Geometry::wkb_multilinestring, create_multilinestring);
  92. static Geometry::Class_info multipolygon_class("MULTIPOLYGON",
  93.    Geometry::wkb_multipolygon,
  94.    create_multipolygon);
  95. static Geometry::Class_info 
  96. geometrycollection_class("GEOMETRYCOLLECTION",Geometry::wkb_geometrycollection,
  97.  create_geometrycollection);
  99. static void get_point(double *x, double *y, const char *data)
  100. {
  101.   float8get(*x, data);
  102.   float8get(*y, data + SIZEOF_STORED_DOUBLE);
  103. }
  105. /***************************** Geometry *******************************/
  107. Geometry::Class_info *Geometry::find_class(const char *name, uint32 len)
  108. {
  109.   for (Class_info **cur_rt= ci_collection;
  110.        cur_rt < ci_collection_end; cur_rt++)
  111.   {
  112.     if (*cur_rt &&
  113. ((*cur_rt)->m_name.length == len) &&
  114. (my_strnncoll(&my_charset_latin1,
  115.       (const uchar*) (*cur_rt)->m_name.str, len,
  116.       (const uchar*) name, len) == 0))
  117.       return *cur_rt;
  118.   }
  119.   return 0;
  120. }
  123. Geometry *Geometry::construct(Geometry_buffer *buffer,
  124.                               const char *data, uint32 data_len)
  125. {
  126.   uint32 geom_type;
  127.   Geometry *result;
  128.   char byte_order;
  130.   if (data_len < SRID_SIZE + WKB_HEADER_SIZE)   // < 4 + (1 + 4)
  131.     return NULL;
  132.   byte_order= data[SRID_SIZE];
  133.   geom_type= uint4korr(data + SRID_SIZE + 1);
  134.   if (!(result= create_by_typeid(buffer, (int) geom_type)))
  135.     return NULL;
  136.   result->m_data= data+ SRID_SIZE + WKB_HEADER_SIZE;
  137.   result->m_data_end= data + data_len;
  138.   return result;
  139. }
  142. Geometry *Geometry::create_from_wkt(Geometry_buffer *buffer,
  143.     Gis_read_stream *trs, String *wkt,
  144.     bool init_stream)
  145. {
  146.   LEX_STRING name;
  147.   Class_info *ci;
  149.   if (trs->get_next_word(&name))
  150.   {
  151.     trs->set_error_msg("Geometry name expected");
  152.     return NULL;
  153.   }
  154.   if (!(ci= find_class(name.str, name.length)) ||
  155.       wkt->reserve(1 + 4, 512))
  156.     return NULL;
  157.   (*ci->m_create_func)((void *)buffer);
  158.   Geometry *result= (Geometry *)buffer;
  159.   
  160.   wkt->q_append((char) wkb_ndr);
  161.   wkt->q_append((uint32) result->get_class_info()->m_type_id);
  162.   if (trs->check_next_symbol('(') ||
  163.       result->init_from_wkt(trs, wkt) ||
  164.       trs->check_next_symbol(')'))
  165.     return NULL;
  166.   if (init_stream)  
  167.   {
  168.     result->set_data_ptr(wkt->ptr(), wkt->length());
  169.     result->shift_wkb_header();
  170.   }
  171.   return result;
  172. }
  175. static double wkb_get_double(const char *ptr, Geometry::wkbByteOrder bo)
  176. {
  177.   double res;
  178.   if (bo != Geometry::wkb_xdr)
  179.     float8get(res, ptr);
  180.   else
  181.   {
  182.     char inv_array[8];
  183.     inv_array[0]= ptr[7];
  184.     inv_array[1]= ptr[6];
  185.     inv_array[2]= ptr[5];
  186.     inv_array[3]= ptr[4];
  187.     inv_array[4]= ptr[3];
  188.     inv_array[5]= ptr[2];
  189.     inv_array[6]= ptr[1];
  190.     inv_array[7]= ptr[0];
  191.     float8get(res, inv_array);
  192.   }
  193.   return res;
  194. }
  197. static uint32 wkb_get_uint(const char *ptr, Geometry::wkbByteOrder bo)
  198. {
  199.   if (bo != Geometry::wkb_xdr)
  200.     return uint4korr(ptr);
  201.   /* else */
  202.   {
  203.     char inv_array[4];
  204.     inv_array[0]= ptr[3];
  205.     inv_array[1]= ptr[2];
  206.     inv_array[2]= ptr[1];
  207.     inv_array[3]= ptr[0];
  208.     return uint4korr(inv_array);
  209.   }
  210. }
  213. int Geometry::create_from_wkb(Geometry_buffer *buffer,
  214.                               const char *wkb, uint32 len, String *res)
  215. {
  216.   uint32 geom_type;
  217.   Geometry *geom;
  219.   if (len < WKB_HEADER_SIZE)
  220.     return 1;
  221.   geom_type= wkb_get_uint(wkb+1, (wkbByteOrder)wkb[0]);
  222.   if (!(geom= create_by_typeid(buffer, (int) geom_type)) ||
  223.       res->reserve(WKB_HEADER_SIZE, 512))
  224.     return 1;
  226.   res->q_append((char) wkb_ndr);
  227.   res->q_append(geom_type);
  228.   return geom->init_from_wkb(wkb+WKB_HEADER_SIZE, len - WKB_HEADER_SIZE,
  229.                              (wkbByteOrder) wkb[0], res);
  230. }
  233. bool Geometry::envelope(String *result) const
  234. {
  235.   MBR mbr;
  236.   const char *end;
  238.   if (get_mbr(&mbr, &end) || result->reserve(1+4*3+SIZEOF_STORED_DOUBLE*10))
  239.     return 1;
  241.   result->q_append((char) wkb_ndr);
  242.   result->q_append((uint32) wkb_polygon);
  243.   result->q_append((uint32) 1);
  244.   result->q_append((uint32) 5);
  245.   result->q_append(mbr.xmin);
  246.   result->q_append(mbr.ymin);
  247.   result->q_append(mbr.xmax);
  248.   result->q_append(mbr.ymin);
  249.   result->q_append(mbr.xmax);
  250.   result->q_append(mbr.ymax);
  251.   result->q_append(mbr.xmin);
  252.   result->q_append(mbr.ymax);
  253.   result->q_append(mbr.xmin);
  254.   result->q_append(mbr.ymin);
  256.   return 0;
  257. }
  260. /*
  261.   Create a point from data.
  263.   SYNPOSIS
  264.     create_point()
  265.     result Put result here
  266.     data Data for point is here.
  268.   RETURN
  269.     0 ok
  270.     1 Can't reallocate 'result'
  271. */
  273. bool Geometry::create_point(String *result, const char *data) const
  274. {
  275.   if (no_data(data, SIZEOF_STORED_DOUBLE * 2) ||
  276.       result->reserve(1 + 4 + SIZEOF_STORED_DOUBLE * 2))
  277.     return 1;
  278.   result->q_append((char) wkb_ndr);
  279.   result->q_append((uint32) wkb_point);
  280.   /* Copy two double in same format */
  281.   result->q_append(data, SIZEOF_STORED_DOUBLE*2);
  282.   return 0;
  283. }
  285. /*
  286.   Create a point from coordinates.
  288.   SYNPOSIS
  289.     create_point()
  290.     result Put result here
  291.     x x coordinate for point
  292.     y y coordinate for point
  294.   RETURN
  295.     0 ok
  296.     1 Can't reallocate 'result'
  297. */
  299. bool Geometry::create_point(String *result, double x, double y) const
  300. {
  301.   if (result->reserve(1 + 4 + SIZEOF_STORED_DOUBLE * 2))
  302.     return 1;
  304.   result->q_append((char) wkb_ndr);
  305.   result->q_append((uint32) wkb_point);
  306.   result->q_append(x);
  307.   result->q_append(y);
  308.   return 0;
  309. }
  311. /*
  312.   Append N points from packed format to text
  314.   SYNOPSIS
  315.     append_points()
  316.     txt Append points here
  317.     n_points Number of points
  318.     data Packed data
  319.     offset Offset between points
  321.   RETURN
  322.     # end of data
  323. */
  325. const char *Geometry::append_points(String *txt, uint32 n_points,
  326.     const char *data, uint32 offset) const
  327. {      
  328.   while (n_points--)
  329.   {
  330.     double x,y;
  331.     data+= offset;
  332.     get_point(&x, &y, data);
  333.     data+= SIZEOF_STORED_DOUBLE * 2;
  334.     txt->qs_append(x);
  335.     txt->qs_append(' ');
  336.     txt->qs_append(y);
  337.     txt->qs_append(',');
  338.   }
  339.   return data;
  340. }
  343. /*
  344.   Get most bounding rectangle (mbr) for X points
  346.   SYNOPSIS
  347.     get_mbr_for_points()
  348.     mbr MBR (store rectangle here)
  349.     points Number of points
  350.     data Packed data
  351.     offset Offset between points
  353.   RETURN
  354.     0 Wrong data
  355.     # end of data
  356. */
  358. const char *Geometry::get_mbr_for_points(MBR *mbr, const char *data,
  359.  uint offset) const
  360. {
  361.   uint32 points;
  362.   /* read number of points */
  363.   if (no_data(data, 4))
  364.     return 0;
  365.   points= uint4korr(data);
  366.   data+= 4;
  368.   if (no_data(data, (SIZEOF_STORED_DOUBLE * 2 + offset) * points))
  369.     return 0;
  371.   /* Calculate MBR for points */
  372.   while (points--)
  373.   {
  374.     data+= offset;
  375.     mbr->add_xy(data, data + SIZEOF_STORED_DOUBLE);
  376.     data+= SIZEOF_STORED_DOUBLE * 2;
  377.   }
  378.   return data;
  379. }
  382. /***************************** Point *******************************/
  384. uint32 Gis_point::get_data_size() const
  385. {
  386.   return POINT_DATA_SIZE;
  387. }
  390. bool Gis_point::init_from_wkt(Gis_read_stream *trs, String *wkb)
  391. {
  392.   double x, y;
  393.   if (trs->get_next_number(&x) || trs->get_next_number(&y) ||
  394.       wkb->reserve(SIZEOF_STORED_DOUBLE * 2))
  395.     return 1;
  396.   wkb->q_append(x);
  397.   wkb->q_append(y);
  398.   return 0;
  399. }
  402. uint Gis_point::init_from_wkb(const char *wkb, uint len,
  403.                               wkbByteOrder bo, String *res)
  404. {
  405.   double x, y;
  406.   if (len < POINT_DATA_SIZE || res->reserve(POINT_DATA_SIZE))
  407.     return 0;
  408.   x= wkb_get_double(wkb, bo);
  409.   y= wkb_get_double(wkb + SIZEOF_STORED_DOUBLE, bo);
  410.   res->q_append(x);
  411.   res->q_append(y);
  412.   return POINT_DATA_SIZE;
  413. }
  416. bool Gis_point::get_data_as_wkt(String *txt, const char **end) const
  417. {
  418.   double x, y;
  419.   if (get_xy(&x, &y))
  420.     return 1;
  421.   if (txt->reserve(MAX_DIGITS_IN_DOUBLE * 2 + 1))
  422.     return 1;
  423.   txt->qs_append(x);
  424.   txt->qs_append(' ');
  425.   txt->qs_append(y);
  426.   *end= m_data+ POINT_DATA_SIZE;
  427.   return 0;
  428. }
  431. bool Gis_point::get_mbr(MBR *mbr, const char **end) const
  432. {
  433.   double x, y;
  434.   if (get_xy(&x, &y))
  435.     return 1;
  436.   mbr->add_xy(x, y);
  437.   *end= m_data+ POINT_DATA_SIZE;
  438.   return 0;
  439. }
  441. const Geometry::Class_info *Gis_point::get_class_info() const
  442. {
  443.   return &point_class;
  444. }
  447. /***************************** LineString *******************************/
  449. uint32 Gis_line_string::get_data_size() const 
  450. {
  451.   if (no_data(m_data, 4))
  452.     return GET_SIZE_ERROR;
  453.   return 4 + uint4korr(m_data) * POINT_DATA_SIZE;
  454. }
  457. bool Gis_line_string::init_from_wkt(Gis_read_stream *trs, String *wkb)
  458. {
  459.   uint32 n_points= 0;
  460.   uint32 np_pos= wkb->length();
  461.   Gis_point p;
  463.   if (wkb->reserve(4, 512))
  464.     return 1;
  465.   wkb->length(wkb->length()+4); // Reserve space for points  
  467.   for (;;)
  468.   {
  469.     if (p.init_from_wkt(trs, wkb))
  470.       return 1;
  471.     n_points++;
  472.     if (trs->skip_char(',')) // Didn't find ','
  473.       break;
  474.   }
  475.   if (n_points < 1)
  476.   {
  477.     trs->set_error_msg("Too few points in LINESTRING");
  478.     return 1;
  479.   }
  480.   wkb->write_at_position(np_pos, n_points);
  481.   return 0;
  482. }
  485. uint Gis_line_string::init_from_wkb(const char *wkb, uint len,
  486.                                     wkbByteOrder bo, String *res)
  487. {
  488.   uint32 n_points, proper_length;
  489.   const char *wkb_end;
  490.   Gis_point p;
  492.   if (len < 4)
  493.     return 0;
  494.   n_points= wkb_get_uint(wkb, bo);
  495.   proper_length= 4 + n_points * POINT_DATA_SIZE;
  497.   if (len < proper_length || res->reserve(proper_length))
  498.     return 0;
  500.   res->q_append(n_points);
  501.   wkb_end= wkb + proper_length;
  502.   for (wkb+= 4; wkb<wkb_end; wkb+= POINT_DATA_SIZE)
  503.   {
  504.     if (!p.init_from_wkb(wkb, POINT_DATA_SIZE, bo, res))
  505.       return 0;
  506.   }
  508.   return proper_length;
  509. }
  512. bool Gis_line_string::get_data_as_wkt(String *txt, const char **end) const
  513. {
  514.   uint32 n_points;
  515.   const char *data= m_data;
  517.   if (no_data(data, 4))
  518.     return 1;
  519.   n_points= uint4korr(data);
  520.   data += 4;
  522.   if (n_points < 1 ||
  523.       no_data(data, SIZEOF_STORED_DOUBLE * 2 * n_points) ||
  524.       txt->reserve(((MAX_DIGITS_IN_DOUBLE + 1)*2 + 1) * n_points))
  525.     return 1;
  527.   while (n_points--)
  528.   {
  529.     double x, y;
  530.     get_point(&x, &y, data);
  531.     data+= SIZEOF_STORED_DOUBLE * 2;
  532.     txt->qs_append(x);
  533.     txt->qs_append(' ');
  534.     txt->qs_append(y);
  535.     txt->qs_append(',');
  536.   }
  537.   txt->length(txt->length() - 1); // Remove end ','
  538.   *end= data;
  539.   return 0;
  540. }
  543. bool Gis_line_string::get_mbr(MBR *mbr, const char **end) const
  544. {
  545.   return (*end=get_mbr_for_points(mbr, m_data, 0)) == 0;
  546. }
  549. int Gis_line_string::length(double *len) const
  550. {
  551.   uint32 n_points;
  552.   double prev_x, prev_y;
  553.   const char *data= m_data;
  555.   *len= 0; // In case of errors
  556.   if (no_data(data, 4))
  557.     return 1;
  558.   n_points= uint4korr(data);
  559.   data+= 4;
  560.   if (n_points < 1 || no_data(data, SIZEOF_STORED_DOUBLE * 2 * n_points))
  561.     return 1;
  563.   get_point(&prev_x, &prev_y, data);
  564.   data+= SIZEOF_STORED_DOUBLE*2;
  566.   while (--n_points)
  567.   {
  568.     double x, y;
  569.     get_point(&x, &y, data);
  570.     data+= SIZEOF_STORED_DOUBLE * 2;
  571.     *len+= sqrt(pow(prev_x-x,2)+pow(prev_y-y,2));
  572.     prev_x= x;
  573.     prev_y= y;
  574.   }
  575.   return 0;
  576. }
  579. int Gis_line_string::is_closed(int *closed) const
  580. {
  581.   uint32 n_points;
  582.   double x1, y1, x2, y2;
  583.   const char *data= m_data;
  585.   if (no_data(data, 4))
  586.     return 1;
  587.   n_points= uint4korr(data);
  588.   if (n_points == 1)
  589.   {
  590.     *closed=1;
  591.     return 0;
  592.   }
  593.   data+= 4;
  594.   if (no_data(data, SIZEOF_STORED_DOUBLE * 2 * n_points))
  595.     return 1;
  597.   /* Get first point */
  598.   get_point(&x1, &y1, data);
  600.   /* get last point */
  601.   data+= SIZEOF_STORED_DOUBLE*2 + (n_points-2)*POINT_DATA_SIZE;
  602.   get_point(&x2, &y2, data);
  604.   *closed= (x1==x2) && (y1==y2);
  605.   return 0;
  606. }
  609. int Gis_line_string::num_points(uint32 *n_points) const
  610. {
  611.   *n_points= uint4korr(m_data);
  612.   return 0;
  613. }
  616. int Gis_line_string::start_point(String *result) const
  617. {
  618.   /* +4 is for skipping over number of points */
  619.   return create_point(result, m_data + 4);
  620. }
  623. int Gis_line_string::end_point(String *result) const
  624. {
  625.   uint32 n_points;
  626.   if (no_data(m_data, 4))
  627.     return 1;
  628.   n_points= uint4korr(m_data);
  629.   return create_point(result, m_data + 4 + (n_points - 1) * POINT_DATA_SIZE);
  630. }
  633. int Gis_line_string::point_n(uint32 num, String *result) const
  634. {
  635.   uint32 n_points;
  636.   if (no_data(m_data, 4))
  637.     return 1;
  638.   n_points= uint4korr(m_data);
  639.   if ((uint32) (num - 1) >= n_points) // means (num > n_points || num < 1)
  640.     return 1;
  642.   return create_point(result, m_data + 4 + (num - 1) * POINT_DATA_SIZE);
  643. }
  645. const Geometry::Class_info *Gis_line_string::get_class_info() const
  646. {
  647.   return &linestring_class;
  648. }
  651. /***************************** Polygon *******************************/
  653. uint32 Gis_polygon::get_data_size() const 
  654. {
  655.   uint32 n_linear_rings;
  656.   const char *data= m_data;
  658.   if (no_data(data, 4))
  659.     return GET_SIZE_ERROR;
  660.   n_linear_rings= uint4korr(data);
  661.   data+= 4;
  663.   while (n_linear_rings--)
  664.   {
  665.     if (no_data(data, 4))
  666.       return GET_SIZE_ERROR;
  667.     data+= 4 + uint4korr(data)*POINT_DATA_SIZE;
  668.   }
  669.   return (uint32) (data - m_data);
  670. }
  673. bool Gis_polygon::init_from_wkt(Gis_read_stream *trs, String *wkb)
  674. {
  675.   uint32 n_linear_rings= 0;
  676.   uint32 lr_pos= wkb->length();
  677.   int closed;
  679.   if (wkb->reserve(4, 512))
  680.     return 1;
  681.   wkb->length(wkb->length()+4); // Reserve space for points
  682.   for (;;)  
  683.   {
  684.     Gis_line_string ls;
  685.     uint32 ls_pos=wkb->length();
  686.     if (trs->check_next_symbol('(') ||
  687. ls.init_from_wkt(trs, wkb) ||
  688. trs->check_next_symbol(')'))
  689.       return 1;
  691.     ls.set_data_ptr(wkb->ptr() + ls_pos, wkb->length() - ls_pos);
  692.     if (ls.is_closed(&closed) || !closed)
  693.     {
  694.       trs->set_error_msg("POLYGON's linear ring isn't closed");
  695.       return 1;
  696.     }
  697.     n_linear_rings++;
  698.     if (trs->skip_char(',')) // Didn't find ','
  699.       break;
  700.   }
  701.   wkb->write_at_position(lr_pos, n_linear_rings);
  702.   return 0;
  703. }
  706. uint Gis_polygon::init_from_wkb(const char *wkb, uint len, wkbByteOrder bo,
  707.                                 String *res)
  708. {
  709.   uint32 n_linear_rings;
  710.   const char *wkb_orig= wkb;
  712.   if (len < 4)
  713.     return 0;
  715.   n_linear_rings= wkb_get_uint(wkb, bo);
  716.   if (res->reserve(4, 512))
  717.     return 0;
  718.   wkb+= 4;
  719.   len-= 4;
  720.   res->q_append(n_linear_rings);
  722.   while (n_linear_rings--)
  723.   {
  724.     Gis_line_string ls;
  725.     uint32 ls_pos= res->length();
  726.     int ls_len;
  727.     int closed;
  729.     if (!(ls_len= ls.init_from_wkb(wkb, len, bo, res)))
  730.       return 0;
  732.     ls.set_data_ptr(res->ptr() + ls_pos, res->length() - ls_pos);
  734.     if (ls.is_closed(&closed) || !closed)
  735.       return 0;
  736.     wkb+= ls_len;
  737.   }
  739.   return (uint) (wkb - wkb_orig);
  740. }
  743. bool Gis_polygon::get_data_as_wkt(String *txt, const char **end) const
  744. {
  745.   uint32 n_linear_rings;
  746.   const char *data= m_data;
  748.   if (no_data(data, 4))
  749.     return 1;
  751.   n_linear_rings= uint4korr(data);
  752.   data+= 4;
  754.   while (n_linear_rings--)
  755.   {
  756.     uint32 n_points;
  757.     if (no_data(data, 4))
  758.       return 1;
  759.     n_points= uint4korr(data);
  760.     data+= 4;
  761.     if (no_data(data, (SIZEOF_STORED_DOUBLE*2) * n_points) ||
  762. txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
  763.       return 1;
  764.     txt->qs_append('(');
  765.     data= append_points(txt, n_points, data, 0);
  766.     (*txt) [txt->length() - 1]= ')'; // Replace end ','
  767.     txt->qs_append(',');
  768.   }
  769.   txt->length(txt->length() - 1); // Remove end ','
  770.   *end= data;
  771.   return 0;
  772. }
  775. bool Gis_polygon::get_mbr(MBR *mbr, const char **end) const
  776. {
  777.   uint32 n_linear_rings;
  778.   const char *data= m_data;
  780.   if (no_data(data, 4))
  781.     return 1;
  782.   n_linear_rings= uint4korr(data);
  783.   data+= 4;
  785.   while (n_linear_rings--)
  786.   {
  787.     if (!(data= get_mbr_for_points(mbr, data, 0)))
  788.       return 1;
  789.   }
  790.   *end= data;
  791.   return 0;
  792. }
  795. int Gis_polygon::area(double *ar, const char **end_of_data) const
  796. {
  797.   uint32 n_linear_rings;
  798.   double result= -1.0;
  799.   const char *data= m_data;
  801.   if (no_data(data, 4))
  802.     return 1;
  803.   n_linear_rings= uint4korr(data);
  804.   data+= 4;
  806.   while (n_linear_rings--)
  807.   {
  808.     double prev_x, prev_y;
  809.     double lr_area= 0;
  810.     uint32 n_points;
  812.     if (no_data(data, 4))
  813.       return 1;
  814.     n_points= uint4korr(data);
  815.     if (no_data(data, (SIZEOF_STORED_DOUBLE*2) * n_points))
  816.       return 1;
  817.     get_point(&prev_x, &prev_y, data+4);
  818.     data+= (4+SIZEOF_STORED_DOUBLE*2);
  820.     while (--n_points) // One point is already read
  821.     {
  822.       double x, y;
  823.       get_point(&x, &y, data);
  824.       data+= (SIZEOF_STORED_DOUBLE*2);
  825.       /* QQ: Is the following prev_x+x right ? */
  826.       lr_area+= (prev_x + x)* (prev_y - y);
  827.       prev_x= x;
  828.       prev_y= y;
  829.     }
  830.     lr_area= fabs(lr_area)/2;
  831.     if (result == -1.0)
  832.       result= lr_area;
  833.     else
  834.       result-= lr_area;
  835.   }
  836.   *ar= fabs(result);
  837.   *end_of_data= data;
  838.   return 0;
  839. }
  842. int Gis_polygon::exterior_ring(String *result) const
  843. {
  844.   uint32 n_points, length;
  845.   const char *data= m_data + 4; // skip n_linerings
  847.   if (no_data(data, 4))
  848.     return 1;
  849.   n_points= uint4korr(data);
  850.   data+= 4;
  851.   length= n_points * POINT_DATA_SIZE;
  852.   if (no_data(data, length) || result->reserve(1+4+4+ length))
  853.     return 1;
  855.   result->q_append((char) wkb_ndr);
  856.   result->q_append((uint32) wkb_linestring);
  857.   result->q_append(n_points);
  858.   result->q_append(data, n_points * POINT_DATA_SIZE); 
  859.   return 0;
  860. }
  863. int Gis_polygon::num_interior_ring(uint32 *n_int_rings) const
  864. {
  865.   if (no_data(m_data, 4))
  866.     return 1;
  867.   *n_int_rings= uint4korr(m_data)-1;
  868.   return 0;
  869. }
  872. int Gis_polygon::interior_ring_n(uint32 num, String *result) const
  873. {
  874.   const char *data= m_data;
  875.   uint32 n_linear_rings;
  876.   uint32 n_points;
  877.   uint32 points_size;
  879.   if (no_data(data, 4))
  880.     return 1;
  881.   n_linear_rings= uint4korr(data);
  882.   data+= 4;
  884.   if (num >= n_linear_rings || num < 1)
  885.     return 1;
  887.   while (num--)
  888.   {
  889.     if (no_data(data, 4))
  890.       return 1;
  891.     data+= 4 + uint4korr(data) * POINT_DATA_SIZE;
  892.   }
  893.   if (no_data(data, 4))
  894.     return 1;
  895.   n_points= uint4korr(data);
  896.   points_size= n_points * POINT_DATA_SIZE;
  897.   data+= 4;
  898.   if (no_data(data, points_size) || result->reserve(1+4+4+ points_size))
  899.     return 1;
  901.   result->q_append((char) wkb_ndr);
  902.   result->q_append((uint32) wkb_linestring);
  903.   result->q_append(n_points);
  904.   result->q_append(data, points_size); 
  906.   return 0;
  907. }
  910. int Gis_polygon::centroid_xy(double *x, double *y) const
  911. {
  912.   uint32 n_linear_rings;
  913.   double res_area;
  914.   double res_cx, res_cy;
  915.   const char *data= m_data;
  916.   bool first_loop= 1;
  917.   LINT_INIT(res_area);
  918.   LINT_INIT(res_cx);
  919.   LINT_INIT(res_cy);
  921.   if (no_data(data, 4))
  922.     return 1;
  923.   n_linear_rings= uint4korr(data);
  924.   data+= 4;
  926.   while (n_linear_rings--)
  927.   {
  928.     uint32 n_points, org_n_points;
  929.     double prev_x, prev_y;
  930.     double cur_area= 0;
  931.     double cur_cx= 0;
  932.     double cur_cy= 0;
  934.     if (no_data(data, 4))
  935.       return 1;
  936.     org_n_points= n_points= uint4korr(data);
  937.     data+= 4;
  938.     if (no_data(data, (SIZEOF_STORED_DOUBLE*2) * n_points))
  939.       return 1;
  940.     get_point(&prev_x, &prev_y, data);
  941.     data+= (SIZEOF_STORED_DOUBLE*2);
  943.     while (--n_points) // One point is already read
  944.     {
  945.       double x, y;
  946.       get_point(&x, &y, data);
  947.       data+= (SIZEOF_STORED_DOUBLE*2);
  948.       /* QQ: Is the following prev_x+x right ? */
  949.       cur_area+= (prev_x + x) * (prev_y - y);
  950.       cur_cx+= x;
  951.       cur_cy+= y;
  952.       prev_x= x;
  953.       prev_y= y;
  954.     }
  955.     cur_area= fabs(cur_area) / 2;
  956.     cur_cx= cur_cx / (org_n_points - 1);
  957.     cur_cy= cur_cy / (org_n_points - 1);
  959.     if (!first_loop)
  960.     {
  961.       double d_area= fabs(res_area - cur_area);
  962.       res_cx= (res_area * res_cx - cur_area * cur_cx) / d_area;
  963.       res_cy= (res_area * res_cy - cur_area * cur_cy) / d_area;
  964.     }
  965.     else
  966.     {
  967.       first_loop= 0;
  968.       res_area= cur_area;
  969.       res_cx= cur_cx;
  970.       res_cy= cur_cy;
  971.     }
  972.   }
  974.   *x= res_cx;
  975.   *y= res_cy;
  976.   return 0;
  977. }
  980. int Gis_polygon::centroid(String *result) const
  981. {
  982.   double x, y;
  983.   if (centroid_xy(&x, &y))
  984.     return 1;
  985.   return create_point(result, x, y);
  986. }
  988. const Geometry::Class_info *Gis_polygon::get_class_info() const
  989. {
  990.   return &polygon_class;
  991. }
  994. /***************************** MultiPoint *******************************/
  996. uint32 Gis_multi_point::get_data_size() const 
  997. {
  998.   if (no_data(m_data, 4))
  999.     return GET_SIZE_ERROR;
  1000.   return 4 + uint4korr(m_data)*(POINT_DATA_SIZE + WKB_HEADER_SIZE);
  1001. }
  1004. bool Gis_multi_point::init_from_wkt(Gis_read_stream *trs, String *wkb)
  1005. {
  1006.   uint32 n_points= 0;
  1007.   uint32 np_pos= wkb->length();
  1008.   Gis_point p;
  1010.   if (wkb->reserve(4, 512))
  1011.     return 1;
  1012.   wkb->length(wkb->length()+4); // Reserve space for points
  1014.   for (;;)
  1015.   {
  1016.     if (wkb->reserve(1+4, 512))
  1017.       return 1;
  1018.     wkb->q_append((char) wkb_ndr);
  1019.     wkb->q_append((uint32) wkb_point);
  1020.     if (p.init_from_wkt(trs, wkb))
  1021.       return 1;
  1022.     n_points++;
  1023.     if (trs->skip_char(',')) // Didn't find ','
  1024.       break;
  1025.   }
  1026.   wkb->write_at_position(np_pos, n_points); // Store number of found points
  1027.   return 0;
  1028. }
  1031. uint Gis_multi_point::init_from_wkb(const char *wkb, uint len, wkbByteOrder bo,
  1032.                                     String *res)
  1033. {
  1034.   uint32 n_points;
  1035.   uint proper_size;
  1036.   Gis_point p;
  1037.   const char *wkb_end;
  1039.   if (len < 4)
  1040.     return 0;
  1041.   n_points= wkb_get_uint(wkb, bo);
  1042.   proper_size= 4 + n_points * (WKB_HEADER_SIZE + POINT_DATA_SIZE);
  1043.  
  1044.   if (len < proper_size || res->reserve(proper_size))
  1045.     return 0;
  1046.     
  1047.   res->q_append(n_points);
  1048.   wkb_end= wkb + proper_size;
  1049.   for (wkb+=4; wkb < wkb_end; wkb+= (WKB_HEADER_SIZE + POINT_DATA_SIZE))
  1050.   {
  1051.     res->q_append((char)wkb_ndr);
  1052.     res->q_append((uint32)wkb_point);
  1053.     if (!p.init_from_wkb(wkb + WKB_HEADER_SIZE,
  1054.                          POINT_DATA_SIZE, (wkbByteOrder) wkb[0], res))
  1055.       return 0;
  1056.   }
  1057.   return proper_size;
  1058. }
  1061. bool Gis_multi_point::get_data_as_wkt(String *txt, const char **end) const
  1062. {
  1063.   uint32 n_points;
  1064.   if (no_data(m_data, 4))
  1065.     return 1;
  1067.   n_points= uint4korr(m_data);
  1068.   if (no_data(m_data+4,
  1069.       n_points * (SIZEOF_STORED_DOUBLE * 2 + WKB_HEADER_SIZE)) ||
  1070.       txt->reserve(((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
  1071.     return 1;
  1072.   *end= append_points(txt, n_points, m_data+4, WKB_HEADER_SIZE);
  1073.   txt->length(txt->length()-1); // Remove end ','
  1074.   return 0;
  1075. }
  1078. bool Gis_multi_point::get_mbr(MBR *mbr, const char **end) const
  1079. {
  1080.   return (*end= get_mbr_for_points(mbr, m_data, WKB_HEADER_SIZE)) == 0;
  1081. }
  1084. int Gis_multi_point::num_geometries(uint32 *num) const
  1085. {
  1086.   *num= uint4korr(m_data);
  1087.   return 0;
  1088. }
  1091. int Gis_multi_point::geometry_n(uint32 num, String *result) const
  1092. {
  1093.   const char *data= m_data;
  1094.   uint32 n_points;
  1096.   if (no_data(data, 4))
  1097.     return 1;
  1098.   n_points= uint4korr(data);
  1099.   data+= 4+ (num - 1) * (WKB_HEADER_SIZE + POINT_DATA_SIZE);
  1101.   if (num > n_points || num < 1 ||
  1102.       no_data(data, WKB_HEADER_SIZE + POINT_DATA_SIZE) ||
  1103.       result->reserve(WKB_HEADER_SIZE + POINT_DATA_SIZE))
  1104.     return 1;
  1106.   result->q_append(data, WKB_HEADER_SIZE + POINT_DATA_SIZE);
  1107.   return 0;
  1108. }
  1110. const Geometry::Class_info *Gis_multi_point::get_class_info() const
  1111. {
  1112.   return &multipoint_class;
  1113. }
  1116. /***************************** MultiLineString *******************************/
  1118. uint32 Gis_multi_line_string::get_data_size() const 
  1119. {
  1120.   uint32 n_line_strings;
  1121.   const char *data= m_data;
  1123.   if (no_data(data, 4))
  1124.     return GET_SIZE_ERROR;
  1125.   n_line_strings= uint4korr(data);
  1126.   data+= 4;
  1128.   while (n_line_strings--)
  1129.   {
  1130.     if (no_data(data, WKB_HEADER_SIZE + 4))
  1131.       return GET_SIZE_ERROR;
  1132.     data+= (WKB_HEADER_SIZE + 4 + uint4korr(data + WKB_HEADER_SIZE) *
  1133.     POINT_DATA_SIZE);
  1134.   }
  1135.   return (uint32) (data - m_data);
  1136. }
  1139. bool Gis_multi_line_string::init_from_wkt(Gis_read_stream *trs, String *wkb)
  1140. {
  1141.   uint32 n_line_strings= 0;
  1142.   uint32 ls_pos= wkb->length();
  1144.   if (wkb->reserve(4, 512))
  1145.     return 1;
  1146.   wkb->length(wkb->length()+4); // Reserve space for points
  1147.   
  1148.   for (;;)
  1149.   {
  1150.     Gis_line_string ls;
  1152.     if (wkb->reserve(1+4, 512))
  1153.       return 1;
  1154.     wkb->q_append((char) wkb_ndr);
  1155.     wkb->q_append((uint32) wkb_linestring);
  1157.     if (trs->check_next_symbol('(') ||
  1158. ls.init_from_wkt(trs, wkb) ||
  1159. trs->check_next_symbol(')'))
  1160.       return 1;
  1161.     n_line_strings++;
  1162.     if (trs->skip_char(',')) // Didn't find ','
  1163.       break;
  1164.   }
  1165.   wkb->write_at_position(ls_pos, n_line_strings);
  1166.   return 0;
  1167. }
  1170. uint Gis_multi_line_string::init_from_wkb(const char *wkb, uint len,
  1171.                                           wkbByteOrder bo, String *res)
  1172. {
  1173.   uint32 n_line_strings;
  1174.   const char *wkb_orig= wkb;
  1176.   if (len < 4)
  1177.     return 0;
  1178.   n_line_strings= wkb_get_uint(wkb, bo);
  1180.   if (res->reserve(4, 512))
  1181.     return 0;
  1182.   res->q_append(n_line_strings);
  1183.   
  1184.   wkb+= 4;
  1185.   while (n_line_strings--)
  1186.   {
  1187.     Gis_line_string ls;
  1188.     int ls_len;
  1190.     if ((len < WKB_HEADER_SIZE) ||
  1191.         res->reserve(WKB_HEADER_SIZE, 512))
  1192.       return 0;
  1194.     res->q_append((char) wkb_ndr);
  1195.     res->q_append((uint32) wkb_linestring);
  1197.     if (!(ls_len= ls.init_from_wkb(wkb + WKB_HEADER_SIZE, len,
  1198.                                    (wkbByteOrder) wkb[0], res)))
  1199.       return 0;
  1200.     ls_len+= WKB_HEADER_SIZE;;
  1201.     wkb+= ls_len;
  1202.     len-= ls_len;
  1203.   }
  1204.   return (uint) (wkb - wkb_orig);
  1205. }
  1208. bool Gis_multi_line_string::get_data_as_wkt(String *txt, 
  1209.      const char **end) const
  1210. {
  1211.   uint32 n_line_strings;
  1212.   const char *data= m_data;
  1214.   if (no_data(data, 4))
  1215.     return 1;
  1216.   n_line_strings= uint4korr(data);
  1217.   data+= 4;
  1219.   while (n_line_strings--)
  1220.   {
  1221.     uint32 n_points;
  1222.     if (no_data(data, (WKB_HEADER_SIZE + 4)))
  1223.       return 1;
  1224.     n_points= uint4korr(data + WKB_HEADER_SIZE);
  1225.     data+= WKB_HEADER_SIZE + 4;
  1226.     if (no_data(data, n_points * (SIZEOF_STORED_DOUBLE*2)) ||
  1227. txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points))
  1228.       return 1;
  1229.     txt->qs_append('(');
  1230.     data= append_points(txt, n_points, data, 0);
  1231.     (*txt) [txt->length() - 1]= ')';
  1232.     txt->qs_append(',');
  1233.   }
  1234.   txt->length(txt->length() - 1);
  1235.   *end= data;
  1236.   return 0;
  1237. }
  1240. bool Gis_multi_line_string::get_mbr(MBR *mbr, const char **end) const
  1241. {
  1242.   uint32 n_line_strings;
  1243.   const char *data= m_data;
  1245.   if (no_data(data, 4))
  1246.     return 1;
  1247.   n_line_strings= uint4korr(data);
  1248.   data+= 4;
  1250.   while (n_line_strings--)
  1251.   {
  1252.     data+= WKB_HEADER_SIZE;
  1253.     if (!(data= get_mbr_for_points(mbr, data, 0)))
  1254.       return 1;
  1255.   }
  1256.   *end= data;
  1257.   return 0;
  1258. }
  1261. int Gis_multi_line_string::num_geometries(uint32 *num) const
  1262. {
  1263.   *num= uint4korr(m_data);
  1264.   return 0;
  1265. }
  1268. int Gis_multi_line_string::geometry_n(uint32 num, String *result) const
  1269. {
  1270.   uint32 n_line_strings, n_points, length;
  1271.   const char *data= m_data;
  1273.   if (no_data(data, 4))
  1274.     return 1;
  1275.   n_line_strings= uint4korr(data);
  1276.   data+= 4;
  1278.   if ((num > n_line_strings) || (num < 1))
  1279.     return 1;
  1280.  
  1281.   for (;;)
  1282.   {
  1283.     if (no_data(data, WKB_HEADER_SIZE + 4))
  1284.       return 1;
  1285.     n_points= uint4korr(data + WKB_HEADER_SIZE);
  1286.     length= WKB_HEADER_SIZE + 4+ POINT_DATA_SIZE * n_points;
  1287.     if (no_data(data, length))
  1288.       return 1;
  1289.     if (!--num)
  1290.       break;
  1291.     data+= length;
  1292.   }
  1293.   return result->append(data, length, (uint32) 0);
  1294. }
  1297. int Gis_multi_line_string::length(double *len) const
  1298. {
  1299.   uint32 n_line_strings;
  1300.   const char *data= m_data;
  1302.   if (no_data(data, 4))
  1303.     return 1;
  1304.   n_line_strings= uint4korr(data);
  1305.   data+= 4;
  1307.   *len=0;
  1308.   while (n_line_strings--)
  1309.   {
  1310.     double ls_len;
  1311.     Gis_line_string ls;
  1312.     data+= WKB_HEADER_SIZE;
  1313.     ls.set_data_ptr(data, (uint32) (m_data_end - data));
  1314.     if (ls.length(&ls_len))
  1315.       return 1;
  1316.     *len+= ls_len;
  1317.     /*
  1318.       We know here that ls was ok, so we can call the trivial function
  1319.       Gis_line_string::get_data_size without error checking
  1320.     */
  1321.     data+= ls.get_data_size();
  1322.   }
  1323.   return 0;
  1324. }
  1327. int Gis_multi_line_string::is_closed(int *closed) const
  1328. {
  1329.   uint32 n_line_strings;
  1330.   const char *data= m_data;
  1332.   if (no_data(data, 4 + WKB_HEADER_SIZE))
  1333.     return 1;
  1334.   n_line_strings= uint4korr(data);
  1335.   data+= 4 + WKB_HEADER_SIZE;
  1337.   while (n_line_strings--)
  1338.   {
  1339.     Gis_line_string ls;
  1340.     if (no_data(data, 0))
  1341.       return 1;
  1342.     ls.set_data_ptr(data, (uint32) (m_data_end - data));
  1343.     if (ls.is_closed(closed))
  1344.       return 1;
  1345.     if (!*closed)
  1346.       return 0;
  1347.     /*
  1348.       We know here that ls was ok, so we can call the trivial function
  1349.       Gis_line_string::get_data_size without error checking
  1350.     */
  1351.     data+= ls.get_data_size() + WKB_HEADER_SIZE;
  1352.   }
  1353.   return 0;
  1354. }
  1356. const Geometry::Class_info *Gis_multi_line_string::get_class_info() const
  1357. {
  1358.   return &multilinestring_class;
  1359. }
  1362. /***************************** MultiPolygon *******************************/
  1364. uint32 Gis_multi_polygon::get_data_size() const 
  1365. {
  1366.   uint32 n_polygons;
  1367.   const char *data= m_data;
  1369.   if (no_data(data, 4))
  1370.     return GET_SIZE_ERROR;
  1371.   n_polygons= uint4korr(data);
  1372.   data+= 4;
  1374.   while (n_polygons--)
  1375.   {
  1376.     uint32 n_linear_rings;
  1377.     if (no_data(data, 4 + WKB_HEADER_SIZE))
  1378.       return GET_SIZE_ERROR;
  1380.     n_linear_rings= uint4korr(data + WKB_HEADER_SIZE);
  1381.     data+= 4 + WKB_HEADER_SIZE;
  1383.     while (n_linear_rings--)
  1384.     {
  1385.       if (no_data(data, 4))
  1386. return GET_SIZE_ERROR;
  1387.       data+= 4 + uint4korr(data) * POINT_DATA_SIZE;
  1388.     }
  1389.   }
  1390.   return (uint32) (data - m_data);
  1391. }
  1394. bool Gis_multi_polygon::init_from_wkt(Gis_read_stream *trs, String *wkb)
  1395. {
  1396.   uint32 n_polygons= 0;
  1397.   int np_pos= wkb->length();
  1398.   Gis_polygon p;
  1400.   if (wkb->reserve(4, 512))
  1401.     return 1;
  1402.   wkb->length(wkb->length()+4); // Reserve space for points
  1404.   for (;;)  
  1405.   {
  1406.     if (wkb->reserve(1+4, 512))
  1407.       return 1;
  1408.     wkb->q_append((char) wkb_ndr);
  1409.     wkb->q_append((uint32) wkb_polygon);
  1411.     if (trs->check_next_symbol('(') ||
  1412. p.init_from_wkt(trs, wkb) ||
  1413. trs->check_next_symbol(')'))
  1414.       return 1;
  1415.     n_polygons++;
  1416.     if (trs->skip_char(',')) // Didn't find ','
  1417.       break;
  1418.   }
  1419.   wkb->write_at_position(np_pos, n_polygons);
  1420.   return 0;
  1421. }
  1424. uint Gis_multi_polygon::init_from_wkb(const char *wkb, uint len,
  1425.                                       wkbByteOrder bo, String *res)
  1426. {
  1427.   uint32 n_poly;
  1428.   const char *wkb_orig= wkb;
  1430.   if (len < 4)
  1431.     return 0;
  1432.   n_poly= wkb_get_uint(wkb, bo);
  1434.   if (res->reserve(4, 512))
  1435.     return 0;
  1436.   res->q_append(n_poly);
  1437.   
  1438.   wkb+=4;
  1439.   while (n_poly--)
  1440.   {
  1441.     Gis_polygon p;
  1442.     int p_len;
  1444.     if (len < WKB_HEADER_SIZE ||
  1445.         res->reserve(WKB_HEADER_SIZE, 512))
  1446.       return 0;
  1447.     res->q_append((char) wkb_ndr);
  1448.     res->q_append((uint32) wkb_polygon);
  1450.     if (!(p_len= p.init_from_wkb(wkb + WKB_HEADER_SIZE, len,
  1451.                                  (wkbByteOrder) wkb[0], res)))
  1452.       return 0;
  1453.     p_len+= WKB_HEADER_SIZE;
  1454.     wkb+= p_len;
  1455.     len-= p_len;
  1456.   }
  1457.   return (uint) (wkb - wkb_orig);
  1458. }
  1461. bool Gis_multi_polygon::get_data_as_wkt(String *txt, const char **end) const
  1462. {
  1463.   uint32 n_polygons;
  1464.   const char *data= m_data;
  1466.   if (no_data(data, 4))
  1467.     return 1;
  1468.   n_polygons= uint4korr(data);
  1469.   data+= 4;
  1471.   while (n_polygons--)
  1472.   {
  1473.     uint32 n_linear_rings;
  1474.     if (no_data(data, 4 + WKB_HEADER_SIZE) ||
  1475. txt->reserve(1, 512))
  1476.       return 1;
  1477.     n_linear_rings= uint4korr(data+WKB_HEADER_SIZE);
  1478.     data+= 4 + WKB_HEADER_SIZE;
  1479.     txt->q_append('(');
  1481.     while (n_linear_rings--)
  1482.     {
  1483.       if (no_data(data, 4))
  1484.         return 1;
  1485.       uint32 n_points= uint4korr(data);
  1486.       data+= 4;
  1487.       if (no_data(data, (SIZEOF_STORED_DOUBLE * 2) * n_points) ||
  1488.   txt->reserve(2 + ((MAX_DIGITS_IN_DOUBLE + 1) * 2 + 1) * n_points,
  1489.        512))
  1490. return 1;
  1491.       txt->qs_append('(');
  1492.       data= append_points(txt, n_points, data, 0);
  1493.       (*txt) [txt->length() - 1]= ')';
  1494.       txt->qs_append(',');
  1495.     }
  1496.     (*txt) [txt->length() - 1]= ')';
  1497.     txt->qs_append(',');
  1498.   }
  1499.   txt->length(txt->length() - 1);
  1500.   *end= data;
  1501.   return 0;
  1502. }
  1505. bool Gis_multi_polygon::get_mbr(MBR *mbr, const char **end) const
  1506. {
  1507.   uint32 n_polygons;
  1508.   const char *data= m_data;
  1510.   if (no_data(data, 4))
  1511.     return 1;
  1512.   n_polygons= uint4korr(data);
  1513.   data+= 4;
  1515.   while (n_polygons--)
  1516.   {
  1517.     uint32 n_linear_rings;
  1518.     if (no_data(data, 4+WKB_HEADER_SIZE))
  1519.       return 1;
  1520.     n_linear_rings= uint4korr(data + WKB_HEADER_SIZE);
  1521.     data+= WKB_HEADER_SIZE + 4;
  1523.     while (n_linear_rings--)
  1524.     {
  1525.       if (!(data= get_mbr_for_points(mbr, data, 0)))
  1526. return 1;
  1527.     }
  1528.   }
  1529.   *end= data;
  1530.   return 0;
  1531. }
  1534. int Gis_multi_polygon::num_geometries(uint32 *num) const
  1535. {
  1536.   *num= uint4korr(m_data);
  1537.   return 0;
  1538. }
  1541. int Gis_multi_polygon::geometry_n(uint32 num, String *result) const
  1542. {
  1543.   uint32 n_polygons;
  1544.   const char *data= m_data, *start_of_polygon;
  1546.   if (no_data(data, 4))
  1547.     return 1;
  1548.   n_polygons= uint4korr(data);
  1549.   data+= 4;
  1551.   if (num > n_polygons || num < 1)
  1552.     return -1;
  1554.   do
  1555.   {
  1556.     uint32 n_linear_rings;
  1557.     start_of_polygon= data;
  1559.     if (no_data(data, WKB_HEADER_SIZE + 4))
  1560.       return 1;
  1561.     n_linear_rings= uint4korr(data + WKB_HEADER_SIZE);
  1562.     data+= WKB_HEADER_SIZE + 4;
  1564.     while (n_linear_rings--)
  1565.     {
  1566.       uint32 n_points;
  1567.       if (no_data(data, 4))
  1568. return 1;
  1569.       n_points= uint4korr(data);
  1570.       data+= 4 + POINT_DATA_SIZE * n_points;
  1571.     }
  1572.   } while (--num);
  1573.   if (no_data(data, 0)) // We must check last segment
  1574.     return 1;
  1575.   return result->append(start_of_polygon, (uint32) (data - start_of_polygon),
  1576. (uint32) 0);
  1577. }
  1580. int Gis_multi_polygon::area(double *ar,  const char **end_of_data) const
  1581. {
  1582.   uint32 n_polygons;
  1583.   const char *data= m_data;
  1584.   double result= 0;
  1586.   if (no_data(data, 4))
  1587.     return 1;
  1588.   n_polygons= uint4korr(data);
  1589.   data+= 4;
  1591.   while (n_polygons--)
  1592.   {
  1593.     double p_area;
  1594.     Gis_polygon p;
  1596.     data+= WKB_HEADER_SIZE;
  1597.     p.set_data_ptr(data, (uint32) (m_data_end - data));
  1598.     if (p.area(&p_area, &data))
  1599.       return 1;
  1600.     result+= p_area;
  1601.   }
  1602.   *ar= result;
  1603.   *end_of_data= data;
  1604.   return 0;
  1605. }
  1608. int Gis_multi_polygon::centroid(String *result) const
  1609. {
  1610.   uint32 n_polygons;
  1611.   bool first_loop= 1;
  1612.   Gis_polygon p;
  1613.   double res_area, res_cx, res_cy;
  1614.   double cur_area, cur_cx, cur_cy;
  1615.   const char *data= m_data;
  1617.   LINT_INIT(res_area);
  1618.   LINT_INIT(res_cx);
  1619.   LINT_INIT(res_cy);
  1621.   if (no_data(data, 4))
  1622.     return 1;
  1623.   n_polygons= uint4korr(data);
  1624.   data+= 4;
  1626.   while (n_polygons--)
  1627.   {
  1628.     data+= WKB_HEADER_SIZE;
  1629.     p.set_data_ptr(data, (uint32) (m_data_end - data));
  1630.     if (p.area(&cur_area, &data) ||
  1631. p.centroid_xy(&cur_cx, &cur_cy))
  1632.       return 1;
  1634.     if (!first_loop)
  1635.     {
  1636.       double sum_area= res_area + cur_area;
  1637.       res_cx= (res_area * res_cx + cur_area * cur_cx) / sum_area;
  1638.       res_cy= (res_area * res_cy + cur_area * cur_cy) / sum_area;
  1639.     }
  1640.     else
  1641.     {
  1642.       first_loop= 0;
  1643.       res_area= cur_area;
  1644.       res_cx= cur_cx;
  1645.       res_cy= cur_cy;
  1646.     }
  1647.   }
  1649.   return create_point(result, res_cx, res_cy);
  1650. }
  1652. const Geometry::Class_info *Gis_multi_polygon::get_class_info() const
  1653. {
  1654.   return &multipolygon_class;
  1655. }
  1658. /************************* GeometryCollection ****************************/
  1660. uint32 Gis_geometry_collection::get_data_size() const 
  1661. {
  1662.   uint32 n_objects;
  1663.   const char *data= m_data;
  1664.   Geometry_buffer buffer;
  1665.   Geometry *geom;
  1667.   if (no_data(data, 4))
  1668.     return GET_SIZE_ERROR;
  1669.   n_objects= uint4korr(data);
  1670.   data+= 4;
  1672.   while (n_objects--)
  1673.   {
  1674.     uint32 wkb_type,object_size;
  1676.     if (no_data(data, WKB_HEADER_SIZE))
  1677.       return GET_SIZE_ERROR;
  1678.     wkb_type= uint4korr(data + 1);
  1679.     data+= WKB_HEADER_SIZE;
  1681.     if (!(geom= create_by_typeid(&buffer, wkb_type)))
  1682.       return GET_SIZE_ERROR;
  1683.     geom->set_data_ptr(data, (uint) (m_data_end - data));
  1684.     if ((object_size= geom->get_data_size()) == GET_SIZE_ERROR)
  1685.       return GET_SIZE_ERROR;
  1686.     data+= object_size;
  1687.   }
  1688.   return (uint32) (data - m_data);
  1689. }
  1692. bool Gis_geometry_collection::init_from_wkt(Gis_read_stream *trs, String *wkb)
  1693. {
  1694.   uint32 n_objects= 0;
  1695.   uint32 no_pos= wkb->length();
  1696.   Geometry_buffer buffer;
  1697.   Geometry *g;
  1699.   if (wkb->reserve(4, 512))
  1700.     return 1;
  1701.   wkb->length(wkb->length()+4); // Reserve space for points
  1703.   for (;;)
  1704.   {
  1705.     if (!(g= create_from_wkt(&buffer, trs, wkb)))
  1706.       return 1;
  1708.     if (g->get_class_info()->m_type_id == wkb_geometrycollection)
  1709.     {
  1710.       trs->set_error_msg("Unexpected GEOMETRYCOLLECTION");
  1711.       return 1;
  1712.     }
  1713.     n_objects++;
  1714.     if (trs->skip_char(',')) // Didn't find ','
  1715.       break;
  1716.   }
  1718.   wkb->write_at_position(no_pos, n_objects);
  1719.   return 0;
  1720. }
  1723. uint Gis_geometry_collection::init_from_wkb(const char *wkb, uint len,
  1724.                                             wkbByteOrder bo, String *res)
  1725. {
  1726.   uint32 n_geom;
  1727.   const char *wkb_orig= wkb;
  1729.   if (len < 4)
  1730.     return 0;
  1731.   n_geom= wkb_get_uint(wkb, bo);
  1733.   if (res->reserve(4, 512))
  1734.     return 0;
  1735.   res->q_append(n_geom);
  1736.   
  1737.   wkb+= 4;
  1738.   while (n_geom--)
  1739.   {
  1740.     Geometry_buffer buffer;
  1741.     Geometry *geom;
  1742.     int g_len;
  1743.     uint32 wkb_type;
  1745.     if (len < WKB_HEADER_SIZE ||
  1746.         res->reserve(WKB_HEADER_SIZE, 512))
  1747.       return 0;
  1749.     res->q_append((char) wkb_ndr);
  1750.     wkb_type= wkb_get_uint(wkb+1, (wkbByteOrder) wkb[0]);
  1751.     res->q_append(wkb_type);
  1753.     if (!(geom= create_by_typeid(&buffer, wkb_type)) ||
  1754.         !(g_len= geom->init_from_wkb(wkb + WKB_HEADER_SIZE, len,
  1755.                                      (wkbByteOrder)  wkb[0], res)))
  1756.       return 0;
  1757.     g_len+= WKB_HEADER_SIZE;
  1758.     wkb+= g_len;
  1759.     len-= g_len;
  1760.   }
  1761.   return (uint) (wkb - wkb_orig);
  1762. }
  1765. bool Gis_geometry_collection::get_data_as_wkt(String *txt,
  1766.      const char **end) const
  1767. {
  1768.   uint32 n_objects;
  1769.   Geometry_buffer buffer;
  1770.   Geometry *geom;
  1771.   const char *data= m_data;
  1773.   if (no_data(data, 4))
  1774.     return 1;
  1775.   n_objects= uint4korr(data);
  1776.   data+= 4;
  1778.   while (n_objects--)
  1779.   {
  1780.     uint32 wkb_type;
  1782.     if (no_data(data, WKB_HEADER_SIZE))
  1783.       return 1;
  1784.     wkb_type= uint4korr(data + 1);
  1785.     data+= WKB_HEADER_SIZE;
  1787.     if (!(geom= create_by_typeid(&buffer, wkb_type)))
  1788.       return 1;
  1789.     geom->set_data_ptr(data, (uint) (m_data_end - data));
  1790.     if (geom->as_wkt(txt, &data))
  1791.       return 1;
  1792.     if (txt->append(",", 1, 512))
  1793.       return 1;
  1794.   }
  1795.   txt->length(txt->length() - 1);
  1796.   *end= data;
  1797.   return 0;
  1798. }
  1801. bool Gis_geometry_collection::get_mbr(MBR *mbr, const char **end) const
  1802. {
  1803.   uint32 n_objects;
  1804.   const char *data= m_data;
  1805.   Geometry_buffer buffer;
  1806.   Geometry *geom;
  1808.   if (no_data(data, 4))
  1809.     return 1;
  1810.   n_objects= uint4korr(data);
  1811.   data+= 4;
  1813.   while (n_objects--)
  1814.   {
  1815.     uint32 wkb_type;
  1817.     if (no_data(data, WKB_HEADER_SIZE))
  1818.       return 1;
  1819.     wkb_type= uint4korr(data + 1);
  1820.     data+= WKB_HEADER_SIZE;
  1822.     if (!(geom= create_by_typeid(&buffer, wkb_type)))
  1823.       return 1;
  1824.     geom->set_data_ptr(data, (uint32) (m_data_end - data));
  1825.     if (geom->get_mbr(mbr, &data))
  1826.       return 1;
  1827.   }
  1828.   *end= data;
  1829.   return 0;
  1830. }
  1833. int Gis_geometry_collection::num_geometries(uint32 *num) const
  1834. {
  1835.   if (no_data(m_data, 4))
  1836.     return 1;
  1837.   *num= uint4korr(m_data);
  1838.   return 0;
  1839. }
  1842. int Gis_geometry_collection::geometry_n(uint32 num, String *result) const
  1843. {
  1844.   uint32 n_objects, wkb_type, length;
  1845.   const char *data= m_data;
  1846.   Geometry_buffer buffer;
  1847.   Geometry *geom;
  1849.   if (no_data(data, 4))
  1850.     return 1;
  1851.   n_objects= uint4korr(data);
  1852.   data+= 4;
  1853.   if (num > n_objects || num < 1)
  1854.     return 1;
  1856.   do
  1857.   {
  1858.     if (no_data(data, WKB_HEADER_SIZE))
  1859.       return 1;
  1860.     wkb_type= uint4korr(data + 1);
  1861.     data+= WKB_HEADER_SIZE;
  1863.     if (!(geom= create_by_typeid(&buffer, wkb_type)))
  1864.       return 1;
  1865.     geom->set_data_ptr(data, (uint) (m_data_end - data));
  1866.     if ((length= geom->get_data_size()) == GET_SIZE_ERROR)
  1867.       return 1;
  1868.     data+= length;
  1869.   } while (--num);
  1871.   /* Copy found object to result */
  1872.   if (result->reserve(1+4+length))
  1873.     return 1;
  1874.   result->q_append((char) wkb_ndr);
  1875.   result->q_append((uint32) wkb_type);
  1876.   result->q_append(data-length, length); // data-length = start_of_data
  1877.   return 0;
  1878. }
  1881. /*
  1882.   Return dimension for object
  1884.   SYNOPSIS
  1885.     dimension()
  1886.     res_dim Result dimension
  1887.     end End of object will be stored here. May be 0 for
  1888. simple objects!
  1889.   RETURN
  1890.     0 ok
  1891.     1 error
  1892. */
  1894. bool Gis_geometry_collection::dimension(uint32 *res_dim, const char **end) const
  1895. {
  1896.   uint32 n_objects;
  1897.   const char *data= m_data;
  1898.   Geometry_buffer buffer;
  1899.   Geometry *geom;
  1901.   if (no_data(data, 4))
  1902.     return 1;
  1903.   n_objects= uint4korr(data);
  1904.   data+= 4;
  1906.   *res_dim= 0;
  1907.   while (n_objects--)
  1908.   {
  1909.     uint32 wkb_type, length, dim;
  1910.     const char *end_data;
  1912.     if (no_data(data, WKB_HEADER_SIZE))
  1913.       return 1;
  1914.     wkb_type= uint4korr(data + 1);
  1915.     data+= WKB_HEADER_SIZE;
  1916.     if (!(geom= create_by_typeid(&buffer, wkb_type)))
  1917.       return 1;
  1918.     geom->set_data_ptr(data, (uint32) (m_data_end - data));
  1919.     if (geom->dimension(&dim, &end_data))
  1920.       return 1;
  1921.     set_if_bigger(*res_dim, dim);
  1922.     if (end_data) // Complex object
  1923.       data= end_data;
  1924.     else if ((length= geom->get_data_size()) == GET_SIZE_ERROR)
  1925.       return 1;
  1926.     else
  1927.       data+= length;
  1928.   }
  1929.   *end= data;
  1930.   return 0;
  1931. }
  1933. const Geometry::Class_info *Gis_geometry_collection::get_class_info() const
  1934. {
  1935.   return &geometrycollection_class;
  1936. }
  1938. #endif /*HAVE_SPATIAL*/