# VectorDataIOExample.cxx¶

Example source code (VectorDataIOExample.cxx):

//  Unfortunately, many vector data formats do not
//  share the models for the data they represent. However, in some
//  cases, when simple data is stored, it can be decomposed in simple
//  objects as for instance polylines, polygons and points. This is
//  the case for the Shapefile and the KML (Keyhole Markup Language) formats,
//  for instance.
//
//  are available in OTB, we designed a generic approach for the IO of
//  this kind of data.

//  The reader/writer for VectorData in OTB is able to access a variety of
//  vector file formats (all OGR supported formats)
//
//  how projections work for the vector data and how you can export
//  the results obtained with OTB to the real world.
//
//  This example illustrates the use of OTB's vector data IO
//  framework.
//
//  We will start by including the header files for the classes
//  describing the vector data and the corresponding reader and writer.

#include "otbVectorData.h"
#include "otbVectorDataFileWriter.h"
//  We will also need to include the header files for the classes
//  which model the individual objects that we get from the vector
//  data structure.

#include "itkPreOrderTreeIterator.h"
#include "otbObjectList.h"
#include "otbPolygon.h"

int main(int argc, char* argv[])
{

if (argc != 3)
{
std::cerr << "Usage: " << argv[0];
std::cerr << "inputFile outputFile" << std::endl;
return EXIT_FAILURE;
}

using PixelType = unsigned short;

//  We define the types for the vector data structure and the

using VectorDataType = otb::VectorData<PixelType, 2>;

//  The vector data obtained from the reader will provide a tree of
//  nodes containing the actual objects of the scene. This tree will
//  be accessed using an \doxygen{itk}{PreOrderTreeIterator}.

using DataTreeType     = VectorDataType::DataTreeType;
using TreeIteratorType = itk::PreOrderTreeIterator<DataTreeType>;
//  In this example we will only read polygon objects from the input
//  file before writing them to the output file. We define the type
//  for the polygon object as well as an iterator to the vertices. The
//  polygons obtained will be stored in an \doxygen{otb}{ObjectList}.

using PolygonType     = otb::Polygon<double>;
using PolygonListType = otb::ObjectList<PolygonType>;

PolygonListType::Pointer polygonList = PolygonListType::New();
//  We get the data tree and instantiate an iterator to walk through it.

it.GoToBegin();
//  We check that the current object is a polygon using the
//  \code{IsPolygonFeature()} method and get its exterior ring in
//  order to store it into the list.

while (!it.IsAtEnd())
{
if (it.Get()->IsPolygonFeature())
{
polygonList->PushBack(it.Get()->GetPolygonExteriorRing());
}
++it;
}

polygonList->PushBack(PolygonType::New());

//  Before writing the polygons to the output file, we have to build
//  the vector data structure. This structure will be built up of
//  nodes. We define the types needed for that.

VectorDataType::Pointer outVectorData = VectorDataType::New();

using DataNodeType = VectorDataType::DataNodeType;
//  We fill the data structure with the nodes. The root node is a
//  document which is composed of folders. A list of polygons can be
//  seen as a multi polygon object.

DataNodeType::Pointer document = DataNodeType::New();
document->SetNodeType(otb::DOCUMENT);
document->SetNodeId("polygon");
DataNodeType::Pointer folder = DataNodeType::New();
folder->SetNodeType(otb::FOLDER);
DataNodeType::Pointer multiPolygon = DataNodeType::New();
multiPolygon->SetNodeType(otb::FEATURE_MULTIPOLYGON);
//  We assign these objects to the data tree stored by the vector data object.

DataTreeType::Pointer tree = outVectorData->GetDataTree();
DataNodeType::Pointer root = tree->GetRoot()->Get();

//  We can now iterate through the polygon list and fill the vector
//  data structure.

for (PolygonListType::Iterator pit = polygonList->Begin(); pit != polygonList->End(); ++pit)
{
DataNodeType::Pointer newPolygon = DataNodeType::New();
newPolygon->SetPolygonExteriorRing(pit.Get());
}
//  And finally we write the vector data to a file using a generic
//  \doxygen{otb}{VectorDataFileWriter}.

using WriterType = otb::VectorDataFileWriter<VectorDataType>;

WriterType::Pointer writer = WriterType::New();
writer->SetInput(outVectorData);
writer->SetFileName(argv[2]);
writer->Update();

return EXIT_SUCCESS;

//  This example can  convert an ESRI Shapefile to
//  a MapInfo File but you can also access with the same OTB source code
//  to a PostgreSQL datasource, using a connection string as :