src/terralib/maptools/serialization/xml/Utils.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
2 
3  This file is part of the TerraLib - a Framework for building GIS enabled applications.
4 
5  TerraLib is free software: you can redistribute it and/or modify
6  it under the terms of the GNU Lesser General Public License as published by
7  the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  TerraLib is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU Lesser General Public License for more details.
14 
15  You should have received a copy of the GNU Lesser General Public License
16  along with TerraLib. See COPYING. If not, write to
17  TerraLib Team at <terralib-team@terralib.org>.
18  */
19 
20 /*!
21  \file src/terralib/maptools/serialization/xml/Utils.cpp
22 
23  \brief Auxiliary functions to read layer information from a XML document.
24 */
25 
26 // TerraLib
27 #include "../../../se/serialization/xml/Symbolizer.h"
28 #include "../../../srs/Config.h"
29 #include "../../../srs/Exception.h"
30 #include "../../../srs/SpatialReferenceSystemManager.h"
31 #include "../../../xml/AbstractWriter.h"
32 #include "../../../xml/Reader.h"
33 #include "../../AbstractLayer.h"
34 #include "../../Chart.h"
35 #include "../../Enums.h"
36 #include "../../Grouping.h"
37 #include "../../RasterContrast.h"
38 #include "Utils.h"
39 
40 // Boost
41 #include <boost/lexical_cast.hpp>
42 
43 // STL
44 #include <cassert>
45 
46 te::map::Visibility te::map::serialize::GetVisibility(const std::string& visible)
47 {
48  return (visible == "VISIBLE") ? te::map::VISIBLE :
49  (visible == "NOT_VISIBLE") ? te::map::NOT_VISIBLE :
50  te::map::PARTIALLY_VISIBLE;
51 }
52 
53 std::string te::map::serialize::GetVisibility(const te::map::Visibility& visible)
54 {
55  return (visible == te::map::VISIBLE) ? "VISIBLE" :
56  (visible == te::map::NOT_VISIBLE) ? "NOT_VISIBLE" :
57  "PARTIALLY_VISIBLE";
58 }
59 
60 te::map::GroupingType te::map::serialize::GetGroupingType(const std::string& type)
61 {
62  if(type == "EQUAL_STEPS")
63  return te::map::EQUAL_STEPS;
64 
65  if(type == "QUANTIL")
66  return te::map::QUANTIL;
67 
68  if(type == "STD_DEVIATION")
69  return te::map::STD_DEVIATION;
70 
71  assert(type == "UNIQUE_VALUE");
72 
73  return te::map::UNIQUE_VALUE;
74 }
75 
76 std::string te::map::serialize::GetGroupingType(const te::map::GroupingType& type)
77 {
78  switch(type)
79  {
80  case te::map::EQUAL_STEPS:
81  return "EQUAL_STEPS";
82 
83  case te::map::QUANTIL:
84  return "QUANTIL";
85 
86  case te::map::STD_DEVIATION:
87  return "STD_DEVIATION";
88 
89  default:
90  {
91  assert(type == te::map::UNIQUE_VALUE);
92  return "UNIQUE_VALUE";
93  }
94  }
95 }
96 
97 std::string te::map::serialize::ReadLayerTitle(te::xml::Reader& reader)
98 {
99  assert(reader.getNodeType() == te::xml::START_ELEMENT);
100  assert(reader.getElementLocalName() == "Title");
101  reader.next();
102  assert(reader.getNodeType() == te::xml::VALUE);
103  std::string title = reader.getElementValue();
104  reader.next();
105  assert(reader.getNodeType() == te::xml::END_ELEMENT);
106 
107  return title;
108 }
109 
110 std::string te::map::serialize::ReadLayerEncoding(te::xml::Reader& reader)
111 {
112  std::string encoding;
113 
114  if (reader.getNodeType() == te::xml::START_ELEMENT &&
115  reader.getElementLocalName() == "Encoding")
116  {
117  reader.next();
118  assert(reader.getNodeType() == te::xml::VALUE);
119  encoding = reader.getElementValue();
120  reader.next();
121  assert(reader.getNodeType() == te::xml::END_ELEMENT);
122  }
123 
124  return encoding;
125 }
126 
127 std::string te::map::serialize::ReadDataSetName(te::xml::Reader& reader)
128 {
129  std::string dataset;
130 
131  assert(reader.getNodeType() == te::xml::START_ELEMENT);
132  assert(reader.getElementLocalName() == "DataSetName");
133  reader.next();
134  if (reader.getNodeType() == te::xml::VALUE)
135  {
136  dataset = reader.getElementValue();
137  reader.next();
138  }
139 
140  assert(reader.getNodeType() == te::xml::END_ELEMENT);
141 
142  return dataset;
143 }
144 
145 std::string te::map::serialize::ReadDataSourceId(te::xml::Reader& reader)
146 {
147  std::string datasourceId;
148 
149  assert(reader.getNodeType() == te::xml::START_ELEMENT);
150  assert(reader.getElementLocalName() == "DataSourceId");
151  reader.next();
152  if (reader.getNodeType() == te::xml::VALUE)
153  {
154  datasourceId = reader.getElementValue();
155  reader.next();
156  }
157  assert(reader.getNodeType() == te::xml::END_ELEMENT);
158 
159  return datasourceId;
160 }
161 
162 std::string te::map::serialize::ReadLayerVisibility(te::xml::Reader& reader)
163 {
164  assert(reader.getNodeType() == te::xml::START_ELEMENT);
165  assert(reader.getElementLocalName() == "Visible");
166  reader.next();
167  assert(reader.getNodeType() == te::xml::VALUE);
168  std::string visible = reader.getElementValue();
169  reader.next();
170  assert(reader.getNodeType() == te::xml::END_ELEMENT);
171 
172  return visible;
173 }
174 
175 te::map::Grouping* te::map::serialize::ReadLayerGrouping(te::xml::Reader& reader)
176 {
177  if(reader.getElementLocalName() != "Grouping")
178  return nullptr;
179 
180  /* Property Name */
181  reader.next();
182  assert(reader.getNodeType() == te::xml::START_ELEMENT);
183  assert(reader.getElementLocalName() == "PropertyName");
184  reader.next();
185  assert(reader.getNodeType() == te::xml::VALUE);
186  std::string propertyName = reader.getElementValue();
187  reader.next();
188  assert(reader.getNodeType() == te::xml::END_ELEMENT);
189 
190  /* Property Data Type */
191  reader.next();
192  assert(reader.getNodeType() == te::xml::START_ELEMENT);
193  assert(reader.getElementLocalName() == "PropertyDataType");
194  reader.next();
195  assert(reader.getNodeType() == te::xml::VALUE);
196  int propertyType = reader.getElementValueAsInt32();
197  reader.next();
198  assert(reader.getNodeType() == te::xml::END_ELEMENT);
199 
200  /* Grouping Type */
201  reader.next();
202  assert(reader.getNodeType() == te::xml::START_ELEMENT);
203  assert(reader.getElementLocalName() == "Type");
204  reader.next();
205  assert(reader.getNodeType() == te::xml::VALUE);
206  std::string type = reader.getElementValue();
207  reader.next();
208  assert(reader.getNodeType() == te::xml::END_ELEMENT);
209 
210  /* Precision */
211  reader.next();
212  assert(reader.getNodeType() == te::xml::START_ELEMENT);
213  assert(reader.getElementLocalName() == "Precision");
214  reader.next();
215  assert(reader.getNodeType() == te::xml::VALUE);
216  std::size_t precision = static_cast<std::size_t>(reader.getElementValueAsInt32());
217  reader.next();
218  assert(reader.getNodeType() == te::xml::END_ELEMENT);
219 
220  std::unique_ptr<te::map::Grouping> g(new te::map::Grouping(propertyName, GetGroupingType(type), precision));
221  g->setPropertyType(propertyType);
222 
223  /* Smmary */
224  reader.next();
225  if(reader.getElementLocalName() == "Summary")
226  {
227  assert(reader.getNodeType() == te::xml::START_ELEMENT);
228  reader.next();
229  assert(reader.getNodeType() == te::xml::VALUE);
230  std::string summary = reader.getElementValue();
231  reader.next();
232  assert(reader.getNodeType() == te::xml::END_ELEMENT);
233  g->setSummary(summary);
234  reader.next();
235  }
236 
237  if(reader.getElementLocalName() == "StandardDeviation")
238  {
239  assert(reader.getNodeType() == te::xml::START_ELEMENT);
240  reader.next();
241  assert(reader.getNodeType() == te::xml::VALUE);
242  double stdDeviation = reader.getElementValueAsDouble();
243  reader.next();
244  assert(reader.getNodeType() == te::xml::END_ELEMENT);
245 
246  g->setStdDeviation(stdDeviation);
247 
248  reader.next();
249  }
250 
251  ////////////////////////////////// DEPRECATED////////////////////////
252  /* Grouping Items */
253  while (reader.getNodeType() != te::xml::END_ELEMENT &&
254  reader.getElementLocalName() == "Grouping")
255  {
256  reader.next();
257  }
258  ////////////////////////////////////////////////////////////////////
259 
260  reader.next();
261 
262  return g.release();
263 }
264 
265 te::map::RasterContrast* te::map::serialize::ReadLayerRasterContrast(te::xml::Reader& reader)
266 {
267  if (reader.getElementLocalName() != "RasterContrast")
268  return nullptr;
269 
270  assert(reader.getNodeType() == te::xml::START_ELEMENT);
271  assert(reader.getElementLocalName() == "RasterContrast");
272 
273  reader.next();
274 
275  /* Type */
276  assert(reader.getElementLocalName() == "ContrastType");
277  reader.next();
278  assert(reader.getNodeType() == te::xml::VALUE);
279  int type = reader.getElementValueAsInt32();
280  reader.next();
281  assert(reader.getNodeType() == te::xml::END_ELEMENT);
282 
283  reader.next();
284 
285  /* Type */
286  assert(reader.getElementLocalName() == "NBands");
287  reader.next();
288  assert(reader.getNodeType() == te::xml::VALUE);
289  int nBands = reader.getElementValueAsInt32();
290  reader.next();
291  assert(reader.getNodeType() == te::xml::END_ELEMENT);
292 
293  std::unique_ptr<te::map::RasterContrast> rc(new te::map::RasterContrast(static_cast<te::map::RasterTransform::ContrastType>(type), static_cast<unsigned long>(nBands)));
294 
295  reader.next();
296 
297  /* Contrast Values */
298  for (int i = 0; i < nBands; ++i)
299  {
300  assert(reader.getNodeType() == te::xml::START_ELEMENT);
301  assert(reader.getElementLocalName() == "BandContrast");
302  reader.next();
303 
304  /* gain */
305  assert(reader.getElementLocalName() == "GainContrast");
306  reader.next();
307  assert(reader.getNodeType() == te::xml::VALUE);
308  double gain = reader.getElementValueAsDouble();
309  reader.next();
310  assert(reader.getNodeType() == te::xml::END_ELEMENT);
311 
312  reader.next();
313 
314  /* offset1 */
315  assert(reader.getElementLocalName() == "Offset1Contrast");
316  reader.next();
317  assert(reader.getNodeType() == te::xml::VALUE);
318  double offset1 = reader.getElementValueAsDouble();
319  reader.next();
320  assert(reader.getNodeType() == te::xml::END_ELEMENT);
321 
322  reader.next();
323 
324  /* offset2 */
325  assert(reader.getElementLocalName() == "Offset2Contrast");
326  reader.next();
327  assert(reader.getNodeType() == te::xml::VALUE);
328  double offset2 = reader.getElementValueAsDouble();
329  reader.next();
330  assert(reader.getNodeType() == te::xml::END_ELEMENT);
331 
332  reader.next();
333 
334  /* min */
335  assert(reader.getElementLocalName() == "minContrast");
336  reader.next();
337  assert(reader.getNodeType() == te::xml::VALUE);
338  double min = reader.getElementValueAsDouble();
339  reader.next();
340  assert(reader.getNodeType() == te::xml::END_ELEMENT);
341 
342  reader.next();
343 
344  /* max */
345  assert(reader.getElementLocalName() == "maxContrast");
346  reader.next();
347  assert(reader.getNodeType() == te::xml::VALUE);
348  double max = reader.getElementValueAsDouble();
349  reader.next();
350  assert(reader.getNodeType() == te::xml::END_ELEMENT);
351 
352  reader.next();
353 
354  assert(reader.getNodeType() == te::xml::END_ELEMENT);
355  reader.next();
356 
357  rc->setValues(gain, offset1, offset2, min, max, static_cast<unsigned long>(i));
358  }
359 
360  assert(reader.getNodeType() == te::xml::END_ELEMENT);
361  reader.next();
362 
363  return rc.release();
364 }
365 
366 std::unique_ptr<te::map::Chart> te::map::serialize::ReadLayerChart(te::xml::Reader& reader)
367 {
368  if(reader.getElementLocalName() != "Chart")
369  return std::unique_ptr<te::map::Chart>();
370 
371  assert(reader.getNodeType() == te::xml::START_ELEMENT);
372  assert(reader.getElementLocalName() == "Chart");
373 
374  reader.next();
375 
376  assert(reader.getNodeType() == te::xml::START_ELEMENT);
377  assert(reader.getElementLocalName() == "Type");
378 
379  reader.next();
380 
381  assert(reader.getNodeType() == te::xml::VALUE);
382 
383  te::map::ChartType type = reader.getElementValue() == "PIE" ? te::map::Pie : te::map::Bar;
384 
385  reader.next();
386 
387  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Type
388 
389  reader.next();
390 
391  assert(reader.getNodeType() == te::xml::START_ELEMENT);
392  assert(reader.getElementLocalName() == "ContourColor");
393 
394  reader.next();
395 
396  assert(reader.getNodeType() == te::xml::VALUE);
397 
398  std::string hexColor = reader.getElementValue();
399 
400  te::color::RGBAColor contourColor(hexColor);
401 
402  reader.next();
403 
404  assert(reader.getNodeType() == te::xml::END_ELEMENT); // ContourColor
405 
406  reader.next();
407 
408  assert(reader.getNodeType() == te::xml::START_ELEMENT);
409  assert(reader.getElementLocalName() == "ContourWidth");
410 
411  reader.next();
412 
413  assert(reader.getNodeType() == te::xml::VALUE);
414 
415  std::size_t contourWidth = static_cast<size_t>(reader.getElementValueAsInt32());
416 
417  reader.next();
418 
419  assert(reader.getNodeType() == te::xml::END_ELEMENT); // ContourWidth
420 
421  reader.next();
422 
423  assert(reader.getNodeType() == te::xml::START_ELEMENT);
424  assert(reader.getElementLocalName() == "Height");
425 
426  reader.next();
427 
428  assert(reader.getNodeType() == te::xml::VALUE);
429 
430  std::size_t height = static_cast<size_t>(reader.getElementValueAsInt32());
431 
432  reader.next();
433 
434  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Height
435 
436  reader.next();
437 
438  std::size_t barWidth = std::string::npos;
439 
440  if(reader.getNodeType() == te::xml::START_ELEMENT &&
441  reader.getElementLocalName() == "BarWidth")
442  {
443  reader.next();
444 
445  assert(reader.getNodeType() == te::xml::VALUE);
446 
447  barWidth = static_cast<size_t>(reader.getElementValueAsInt32());
448 
449  reader.next();
450 
451  assert(reader.getNodeType() == te::xml::END_ELEMENT); // BarWidth
452 
453  reader.next();
454  }
455 
456  assert(reader.getNodeType() == te::xml::START_ELEMENT);
457  assert(reader.getElementLocalName() == "IsVisible");
458 
459  reader.next();
460 
461  assert(reader.getNodeType() == te::xml::VALUE);
462 
463  bool isVisible = reader.getElementValueAsBoolean();
464 
465  reader.next();
466 
467  assert(reader.getNodeType() == te::xml::END_ELEMENT); // IsVisible
468 
469  reader.next();
470 
471  double maxValue = 0;
472  if(type == te::map::Bar)
473  {
474  assert(reader.getNodeType() == te::xml::START_ELEMENT);
475  assert(reader.getElementLocalName() == "MaxValue");
476 
477  reader.next();
478 
479  assert(reader.getNodeType() == te::xml::VALUE);
480 
481  maxValue = reader.getElementValueAsDouble();
482 
483  reader.next();
484 
485  assert(reader.getNodeType() == te::xml::END_ELEMENT); // MaxValue
486 
487  reader.next();
488  }
489 
490  std::string summary = "NONE";
491  if(reader.getNodeType() == te::xml::START_ELEMENT &&
492  reader.getElementLocalName() == "Summary")
493  {
494  reader.next();
495 
496  assert(reader.getNodeType() == te::xml::VALUE);
497 
498  summary = reader.getElementValue();
499 
500  reader.next();
501 
502  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Summary
503 
504  reader.next();
505  }
506 
507  std::vector<std::string> properties;
508  std::vector<te::color::RGBAColor> colors;
509 
510  while(reader.getNodeType() == te::xml::START_ELEMENT &&
511  reader.getElementLocalName() == "Slice")
512  {
513  reader.next();
514 
515  assert(reader.getNodeType() == te::xml::START_ELEMENT);
516  assert(reader.getElementLocalName() == "PropertyName");
517 
518  reader.next();
519 
520  assert(reader.getNodeType() == te::xml::VALUE);
521 
522  std::string propName = reader.getElementValue();
523 
524  reader.next();
525 
526  assert(reader.getNodeType() == te::xml::END_ELEMENT); // PropertyName
527 
528  reader.next();
529 
530  assert(reader.getNodeType() == te::xml::START_ELEMENT);
531  assert(reader.getElementLocalName() == "Color");
532 
533  reader.next();
534 
535  assert(reader.getNodeType() == te::xml::VALUE);
536 
537  std::string hColor = reader.getElementValue();
538  te::color::RGBAColor color(hColor);
539 
540  reader.next();
541  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Color
542 
543  reader.next();
544  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Slice
545 
546  reader.next();
547 
548  properties.push_back(propName);
549  colors.push_back(hColor);
550  }
551 
552  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Chart
553 
554  reader.next();
555 
556  std::unique_ptr<te::map::Chart> chart(new te::map::Chart(type, properties, colors));
557  chart->setContourColor(contourColor);
558  chart->setContourWidth(contourWidth);
559  chart->setHeight(height);
560  chart->setVisibility(isVisible);
561  chart->setSummary(summary);
562  if(barWidth != std::string::npos)
563  chart->setBarWidth(barWidth);
564  if(type == te::map::Bar)
565  chart->setMaxValue(maxValue);
566 
567  return chart;
568 }
569 
570 int te::map::serialize::ReadSRIDValue(te::xml::Reader& reader)
571 {
572  assert(reader.getNodeType() == te::xml::START_ELEMENT);
573  assert(reader.getElementLocalName() == "SRSInfo");
574 
575  reader.next();
576 
577  //srid
578  assert(reader.getNodeType() == te::xml::START_ELEMENT);
579  assert(reader.getElementLocalName() == "SRID");
580  reader.next();
581  assert(reader.getNodeType() == te::xml::VALUE);
582  int srid = reader.getElementValueAsInt32();
583  reader.next();
584  assert(reader.getNodeType() == te::xml::END_ELEMENT);
585 
586  reader.next();
587 
588  //proj4
589  assert(reader.getNodeType() == te::xml::START_ELEMENT);
590  assert(reader.getElementLocalName() == "Proj4");
591  reader.next();
592  std::string proj4;
593  if(reader.getNodeType() != te::xml::END_ELEMENT)
594  {
595  proj4 = reader.getElementValue();
596  reader.next();
597  }
598 
599  assert(reader.getNodeType() == te::xml::END_ELEMENT);
600  reader.next();
601 
602  if (srid >= TE_SRS_USER_DEFINED_START_ID && srid != TE_SRS_GOOGLE)
603  {
604  if (srid != 0)
605  {
606  try
607  {
608  std::pair<std::string, unsigned int> sridInfo = te::srs::SpatialReferenceSystemManager::getInstance().getIdFromP4Txt(proj4);
609  srid = static_cast<int>(sridInfo.second);
610  }
611  catch (te::srs::Exception&/* e*/)
612  {
613  std::string strNewSRID = te::srs::SpatialReferenceSystemManager::getInstance().getNewUserDefinedSRID();
614  srid = boost::lexical_cast<int>(strNewSRID);
615  std::string newName = "USER:" + strNewSRID;
616  te::srs::SpatialReferenceSystemManager::getInstance().add(newName, proj4, "", static_cast<unsigned int>(srid), "USER");
617  }
618  }
619  }
620 
621  return srid;
622 }
623 
624 void te::map::serialize::WriteLayerChart(te::map::Chart* chart, te::xml::AbstractWriter& writer)
625 {
626  writer.writeStartElement("te_map:Chart");
627 
628  te::map::ChartType type = chart->getType();
629 
630  writer.writeElement("te_map:Type", (type == te::map::Pie ? "PIE" : "BAR"));
631 
632  writer.writeElement("te_map:ContourColor", chart->getContourColor().getColor());
633 
634  writer.writeElement("te_map:ContourWidth", boost::lexical_cast<int>(chart->getContourWidth()));
635 
636  writer.writeElement("te_map:Height", boost::lexical_cast<int>(chart->getHeight()));
637 
638  if(chart->getType() == te::map::Bar)
639  writer.writeElement("te_map:BarWidth", boost::lexical_cast<int>(chart->getBarWidth()));
640 
641  writer.writeElement("te_map:IsVisible", (chart->isVisible() ? "true" : "false"));
642 
643  if(chart->getType() == te::map::Bar)
644  writer.writeElement("te_map:MaxValue", chart->getMaxValue());
645 
646  if(chart->getSummary() != "NONE")
647  writer.writeElement("te_map:Summary", chart->getSummary());
648 
649  std::vector<std::string> properties = chart->getProperties();
650 
651  for(std::size_t i = 0; i < properties.size(); ++i)
652  {
653  writer.writeStartElement("te_map:Slice");
654 
655  writer.writeElement("te_map:PropertyName", properties[i]);
656 
657  writer.writeElement("te_map:Color", chart->getColor(i).getColor());
658 
659  writer.writeEndElement("te_map:Slice");
660  }
661 
662  writer.writeEndElement("te_map:Chart");
663 }
664 
665 void te::map::serialize::WriteLayerGrouping(te::map::Grouping* g, te::xml::AbstractWriter& writer)
666 {
667  writer.writeStartElement("te_map:Grouping");
668 
669  te::map::GroupingType type = g->getType();
670 
671  writer.writeElement("te_map:PropertyName", g->getPropertyName());
672  writer.writeElement("te_map:PropertyDataType", g->getPropertyType());
673  writer.writeElement("te_map:Type", GetGroupingType(type));
674  writer.writeElement("te_map:Precision", static_cast<unsigned int>(g->getPrecision()));
675 
676  writer.writeElement("te_map:Summary", g->getSummary());
677 
678  if(type == te::map::STD_DEVIATION)
679  writer.writeElement("te_map:StandardDeviation", g->getStdDeviation());
680 
681  writer.writeEndElement("te_map:Grouping");
682 }
683 
684 void te::map::serialize::WriteLayerRasterContrast(te::map::RasterContrast* rc, te::xml::AbstractWriter& writer)
685 {
686  writer.writeStartElement("te_map:RasterContrast");
687 
688  writer.writeElement("te_map:ContrastType", static_cast<int>(rc->getType()));
689  writer.writeElement("te_map:NBands", static_cast<int>(rc->getNBands()));
690 
691  std::size_t nBands = rc->getNBands();
692  std::vector<double> gain, offset1, offset2, min, max;
693 
694  rc->getValues(gain, offset1, offset2, min, max);
695 
696  for (std::size_t t = 0; t < nBands; ++t)
697  {
698  writer.writeStartElement("te_map:BandContrast");
699 
700  writer.writeElement("te_map:GainContrast", gain[t]);
701  writer.writeElement("te_map:Offset1Contrast", offset1[t]);
702  writer.writeElement("te_map:Offset2Contrast", offset2[t]);
703  writer.writeElement("te_map:minContrast", min[t]);
704  writer.writeElement("te_map:maxContrast", max[t]);
705 
706  writer.writeEndElement("te_map:BandContrast");
707  }
708 
709  writer.writeEndElement("te_map:RasterContrast");
710 }
711 
712 void te::map::serialize::WriteAbstractLayer(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer)
713 {
714  writer.writeAttribute("id", layer->getId());
715  writer.writeElement("te_map:Title", layer->getTitle());
716  writer.writeElement("te_map:Visible", GetVisibility(layer->getVisibility()));
717  writer.writeElement("te_map:Encoding", te::core::CharEncoding::getEncodingName(layer->getEncoding()));
718 
719 
720  //grouping
721  te::map::Grouping* g = layer->getGrouping();
722 
723  if(g != nullptr)
724  WriteLayerGrouping(g, writer);
725 
726  //chart
727  te::map::Chart* chart = layer->getChart();
728 
729  if(chart != nullptr)
730  WriteLayerChart(chart, writer);
731 
732  //raster contrast
733  te::map::RasterContrast* rc = layer->getRasterContrast();
734 
735  if (rc != nullptr)
736  WriteLayerRasterContrast(rc, writer);
737 }
738 
739 void te::map::serialize::WriteSRIDValue(const int& srid, te::xml::AbstractWriter& writer)
740 {
741  std::string proj4 = te::srs::SpatialReferenceSystemManager::getInstance().getP4Txt(static_cast<unsigned int>(srid));
742 
743  writer.writeStartElement("te_map:SRSInfo");
744 
745  writer.writeElement("te_map:SRID", srid);
746 
747  writer.writeElement("te_map:Proj4", proj4);
748 
749  writer.writeEndElement("te_map:SRSInfo");
750 }
751 
te::map::serialize::ReadLayerVisibility
TEMAPEXPORT std::string ReadLayerVisibility(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:162
te::map::serialize::WriteAbstractLayer
TEMAPEXPORT void WriteAbstractLayer(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:712
te::map::AbstractLayer::getId
virtual const std::string & getId() const
It returns the layer id.
Definition: AbstractLayer.cpp:98
te::map::ChartType
ChartType
The chart types.
Definition: src/terralib/maptools/Enums.h:164
te::map::Chart::getType
ChartType getType() const
Definition: Chart.cpp:92
te::map::Chart::getProperties
const std::vector< std::string > & getProperties() const
Definition: Chart.cpp:97
te::map::serialize::ReadLayerRasterContrast
TEMAPEXPORT te::map::RasterContrast * ReadLayerRasterContrast(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:265
te::map::serialize::ReadLayerEncoding
TEMAPEXPORT std::string ReadLayerEncoding(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:110
te::map::Grouping::getStdDeviation
const double getStdDeviation() const
It gets the standard deviation used in the Standard Deviation grouping.
Definition: Grouping.cpp:119
te::xml::Reader::getElementValueAsInt32
virtual boost::int32_t getElementValueAsInt32() const
It returns the element data value in the case of VALUE node.
Definition: xml/Reader.cpp:32
te::map::Chart::getBarWidth
std::size_t getBarWidth() const
Definition: Chart.cpp:171
te::xml::Reader
This class models a XML reader object.
Definition: xml/Reader.h:55
te::map::AbstractLayer
This is the base class for layers.
Definition: AbstractLayer.h:77
te::map::Chart::getSummary
std::string getSummary() const
It gets the grouping summary. It is used only in case 1 to n.
Definition: Chart.cpp:211
te::map::Grouping::getPropertyType
int getPropertyType() const
It gets the property type whose values will be grouped.
Definition: Grouping.cpp:78
te::map::serialize::ReadDataSourceId
TEMAPEXPORT std::string ReadDataSourceId(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:145
te::map::AbstractLayer::getTitle
virtual const std::string & getTitle() const
It returns the layer title.
Definition: AbstractLayer.cpp:108
te::xml::AbstractWriter::writeStartElement
virtual void writeStartElement(const std::string &qName)=0
te::map::Grouping::getPrecision
const size_t getPrecision() const
It gets the precision used for the property values.
Definition: Grouping.cpp:99
te::map::serialize::ReadLayerTitle
TEMAPEXPORT std::string ReadLayerTitle(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:97
te::map::Grouping::getPropertyName
std::string getPropertyName() const
It gets the property name whose values will be grouped.
Definition: Grouping.cpp:67
te::map::serialize::WriteLayerRasterContrast
TEMAPEXPORT void WriteLayerRasterContrast(te::map::RasterContrast *rc, te::xml::AbstractWriter &writer)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:684
te::xml::Reader::getElementLocalName
virtual std::string getElementLocalName() const =0
It returns the local part of the element name in the case of an element node.
te::map::serialize::WriteLayerGrouping
TEMAPEXPORT void WriteLayerGrouping(te::map::Grouping *g, te::xml::AbstractWriter &writer)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:665
te::map::AbstractLayer::getVisibility
virtual Visibility getVisibility() const
It returns the layer visibility.
Definition: AbstractLayer.cpp:154
te::map::RasterContrast::getType
const te::map::RasterTransform::ContrastType getType() const
It gets the contrast type.
Definition: RasterContrast.cpp:71
te::xml::AbstractWriter
This class models a XML writer object.
Definition: AbstractWriter.h:49
te::map::serialize::ReadDataSetName
TEMAPEXPORT std::string ReadDataSetName(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:127
te::map::serialize::ReadLayerGrouping
TEMAPEXPORT te::map::Grouping * ReadLayerGrouping(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:175
te::map::AbstractLayer::getChart
virtual te::map::Chart * getChart() const
It returns the Chart associated to the Layer.
Definition: AbstractLayer.cpp:327
TE_SRS_GOOGLE
#define TE_SRS_GOOGLE
Definition: src/terralib/srs/Config.h:328
te::map::serialize::ReadSRIDValue
TEMAPEXPORT int ReadSRIDValue(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:570
te::map::AbstractLayer::getEncoding
te::core::EncodingType getEncoding() const
It returns the encoding type.
Definition: AbstractLayer.cpp:369
te::map::Chart::getMaxValue
double getMaxValue() const
Definition: Chart.cpp:186
te::map::serialize::WriteSRIDValue
TEMAPEXPORT void WriteSRIDValue(const int &srid, te::xml::AbstractWriter &writer)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:739
te::map::Grouping
This class contains the parameters needed for grouping the values of a Property.
Definition: Grouping.h:57
te::map::Chart::getColor
const te::color::RGBAColor & getColor(std::size_t i) const
Definition: Chart.cpp:112
te::xml::AbstractWriter::writeElement
virtual void writeElement(const std::string &qName, const std::string &value)=0
te::core::CharEncoding::getEncodingName
static std::string getEncodingName(EncodingType et)
Retrive a string from a given character encoding type enum.
Definition: CharEncoding.cpp:141
te::map::Chart
This class represents the informations needed to build map charts.
Definition: Chart.h:51
te::common::Singleton< SpatialReferenceSystemManager >::getInstance
static SpatialReferenceSystemManager & getInstance()
It returns a reference to the singleton instance.
te::xml::Reader::getElementValueAsDouble
virtual double getElementValueAsDouble() const
It returns the element data value in the case of VALUE node.
Definition: xml/Reader.cpp:37
te::map::Chart::getHeight
std::size_t getHeight() const
Definition: Chart.cpp:146
te::map::Chart::isVisible
bool isVisible() const
It gets the chart visibility.
Definition: Chart.cpp:191
te::map::serialize::GetGroupingType
TEMAPEXPORT te::map::GroupingType GetGroupingType(const std::string &type)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:60
Utils.h
Auxiliary functions to read layer information from a XML document.
te::xml::Reader::getElementValueAsBoolean
virtual bool getElementValueAsBoolean() const
It returns the element data value in the case of VALUE node.
Definition: xml/Reader.cpp:42
te::map::serialize::GetVisibility
TEMAPEXPORT te::map::Visibility GetVisibility(const std::string &visible)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:46
te::map::AbstractLayer::getRasterContrast
virtual te::map::RasterContrast * getRasterContrast() const
It returns the raster contrast associated to the Layer.
Definition: AbstractLayer.cpp:338
te::map::RasterContrast
This class contains the parameters needed to apply dynamic contrast over a raster.
Definition: RasterContrast.h:52
te::map::serialize::ReadLayerChart
TEMAPEXPORT std::unique_ptr< te::map::Chart > ReadLayerChart(te::xml::Reader &reader)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:366
te::xml::AbstractWriter::writeAttribute
virtual void writeAttribute(const std::string &attName, const std::string &value)=0
te::map::GroupingType
GroupingType
The grouping type associated to the layer.
Definition: src/terralib/maptools/Enums.h:151
te::map::Chart::getContourWidth
std::size_t getContourWidth() const
Definition: Chart.cpp:136
te::map::Chart::getContourColor
const te::color::RGBAColor & getContourColor() const
Definition: Chart.cpp:126
te::map::AbstractLayer::getGrouping
virtual te::map::Grouping * getGrouping() const
It returns the Grouping associated to the Layer.
Definition: AbstractLayer.cpp:316
te::map::RasterContrast::getNBands
std::size_t getNBands()
It gets the contrast number of bands.
Definition: RasterContrast.cpp:76
TE_SRS_USER_DEFINED_START_ID
#define TE_SRS_USER_DEFINED_START_ID
Definition: src/terralib/srs/Config.h:333
te::map::Grouping::getSummary
std::string getSummary() const
It gets the grouping summary. It is used only in case 1 to n.
Definition: Grouping.cpp:139
te::color::RGBAColor
A helper class for 32-bit RGBA (Red-Green-Blue-Alpha channel) color.
Definition: RGBAColor.h:57
te::map::Grouping::getType
const GroupingType getType() const
It gets the grouping type.
Definition: Grouping.cpp:89
te::xml::AbstractWriter::writeEndElement
virtual void writeEndElement(const std::string &qName)=0
te::xml::Reader::getElementValue
virtual std::string getElementValue() const =0
It returns the element data value in the case of VALUE node.
te::xml::Reader::getNodeType
virtual NodeType getNodeType() const =0
It return the type of node read.
GetVisibility
te::qt::widgets::VISIBLE GetVisibility(const te::qt::widgets::TreeItem *item)
Definition: FolderItem.cpp:4
te::map::RasterContrast::getValues
void getValues(std::vector< double > &gain, std::vector< double > &offset1, std::vector< double > &offset2, std::vector< double > &min, std::vector< double > &max)
It get the contrast transformation values.
Definition: RasterContrast.cpp:93
te::map::Visibility
Visibility
Each layer can have three states of visibility.
Definition: src/terralib/maptools/Enums.h:139
te::xml::Reader::next
virtual bool next()=0
It gets the next event to be read.
te::map::serialize::WriteLayerChart
TEMAPEXPORT void WriteLayerChart(te::map::Chart *chart, te::xml::AbstractWriter &writer)
Definition: src/terralib/maptools/serialization/xml/Utils.cpp:624
te::color::RGBAColor::getColor
std::string getColor(const NameFormat format=HexRgb) const
It gets the color encoded using two hexadecimal digits per primary-color component, in the order Red, Green, Blue, if HexRgb format, or Alpha, Red, Green, Blue, if HexArgb format, prefixed with a hash (#) sign.
Definition: RGBAColor.h:371
GetGroupingType
te::map::GroupingType GetGroupingType(TeGroupingMode mode)
Definition: src/terralib/qt/plugins/datasource/terralib4/Utils.cpp:77