OGRErr OGRSpatialReference::exportToXML(char **ppszRawXML, const char *pszDialect) const { CPLXMLNode *psXMLTree = NULL; if (IsGeographic()) { psXMLTree = exportGeogCSToXML(this); } else if (IsProjected()) { psXMLTree = exportProjCSToXML(this); } else return OGRERR_UNSUPPORTED_SRS; *ppszRawXML = CPLSerializeXMLTree(psXMLTree); CPLDestroyXMLNode(psXMLTree); return OGRERR_NONE; }
OGRErr OGRSpatialReference::exportToERM( char *pszProj, char *pszDatum, char *pszUnits ) { strcpy( pszProj, "RAW" ); strcpy( pszDatum, "RAW" ); strcpy( pszUnits, "METERS" ); if( !IsProjected() && !IsGeographic() ) return TRUE; /* -------------------------------------------------------------------- */ /* Try to find the EPSG code. */ /* -------------------------------------------------------------------- */ int nEPSGCode = 0; if( IsProjected() ) { const char *pszAuthName = GetAuthorityName( "PROJCS" ); if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") ) { nEPSGCode = atoi(GetAuthorityCode( "PROJCS" )); } } else if( IsGeographic() ) { const char *pszAuthName = GetAuthorityName( "GEOGCS" ); if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") ) { nEPSGCode = atoi(GetAuthorityCode( "GEOGCS" )); } } /* -------------------------------------------------------------------- */ /* Is our GEOGCS name already defined in ecw_cs.dat? */ /* -------------------------------------------------------------------- */ OGRSpatialReference oSRSWork; const char *pszWKTDatum = GetAttrValue( "DATUM" ); if( pszWKTDatum != NULL && oSRSWork.importFromDict( "ecw_cs.wkt", pszWKTDatum ) == OGRERR_NONE) { strncpy( pszDatum, pszWKTDatum, 32 ); pszDatum[31] = '\0'; } /* -------------------------------------------------------------------- */ /* Is this a "well known" geographic coordinate system? */ /* -------------------------------------------------------------------- */ if( EQUAL(pszDatum,"RAW") ) { int nEPSGGCSCode = GetEPSGGeogCS(); if( nEPSGGCSCode == 4326 ) strcpy( pszDatum, "WGS84" ); else if( nEPSGGCSCode == 4322 ) strcpy( pszDatum, "WGS72DOD" ); else if( nEPSGGCSCode == 4267 ) strcpy( pszDatum, "NAD27" ); else if( nEPSGGCSCode == 4269 ) strcpy( pszDatum, "NAD83" ); else if( nEPSGGCSCode == 4277 ) strcpy( pszDatum, "OSGB36" ); else if( nEPSGGCSCode == 4278 ) strcpy( pszDatum, "OSGB78" ); else if( nEPSGGCSCode == 4201 ) strcpy( pszDatum, "ADINDAN" ); else if( nEPSGGCSCode == 4202 ) strcpy( pszDatum, "AGD66" ); else if( nEPSGGCSCode == 4203 ) strcpy( pszDatum, "AGD84" ); else if( nEPSGGCSCode == 4209 ) strcpy( pszDatum, "ARC1950" ); else if( nEPSGGCSCode == 4210 ) strcpy( pszDatum, "ARC1960" ); else if( nEPSGGCSCode == 4275 ) strcpy( pszDatum, "NTF" ); else if( nEPSGGCSCode == 4283 ) strcpy( pszDatum, "GDA94" ); else if( nEPSGGCSCode == 4284 ) strcpy( pszDatum, "PULKOVO" ); } /* -------------------------------------------------------------------- */ /* Are we working with a geographic (geodetic) coordinate system? */ /* -------------------------------------------------------------------- */ if( IsGeographic() ) { if( EQUAL(pszDatum,"RAW") ) return OGRERR_UNSUPPORTED_SRS; else { strcpy( pszProj, "GEODETIC" ); return OGRERR_NONE; } } /* -------------------------------------------------------------------- */ /* Is this a UTM projection? */ /* -------------------------------------------------------------------- */ int bNorth, nZone; nZone = GetUTMZone( &bNorth ); if( nZone > 0 ) { if( EQUAL(pszDatum,"GDA94") && !bNorth && nZone >= 48 && nZone <= 58) { sprintf( pszProj, "MGA%02d", nZone ); } else { if( bNorth ) sprintf( pszProj, "NUTM%02d", nZone ); else sprintf( pszProj, "SUTM%02d", nZone ); } } /* -------------------------------------------------------------------- */ /* Is our PROJCS name already defined in ecw_cs.dat? */ /* -------------------------------------------------------------------- */ else { const char *pszPROJCS = GetAttrValue( "PROJCS" ); if( pszPROJCS != NULL && oSRSWork.importFromDict( "ecw_cs.wkt", pszPROJCS ) == OGRERR_NONE && oSRSWork.IsProjected() ) { strncpy( pszProj, pszPROJCS, 32 ); pszProj[31] = '\0'; } } /* -------------------------------------------------------------------- */ /* If we have not translated it yet, but we have an EPSG code */ /* then use EPSG:n notation. */ /* -------------------------------------------------------------------- */ if( (EQUAL(pszDatum,"RAW") || EQUAL(pszProj,"RAW")) && nEPSGCode != 0 ) { sprintf( pszProj, "EPSG:%d", nEPSGCode ); sprintf( pszDatum, "EPSG:%d", nEPSGCode ); } /* -------------------------------------------------------------------- */ /* Handle the units. */ /* -------------------------------------------------------------------- */ double dfUnits = GetLinearUnits(); if( fabs(dfUnits-0.3048) < 0.0001 ) strcpy( pszUnits, "FEET" ); else strcpy( pszUnits, "METERS" ); if( EQUAL(pszProj,"RAW") ) return OGRERR_UNSUPPORTED_SRS; else return OGRERR_NONE; }
void Writer::CreatePCEntry(Schema const& buffer_schema) { boost::uint32_t precision = getDefaultedOption<boost::uint32_t>("stream_output_precision"); boost::uint32_t capacity = getDefaultedOption<boost::uint32_t>("capacity"); std::ostringstream oss; oss.setf(std::ios_base::fixed, std::ios_base::floatfield); oss.precision(precision); std::ostringstream columns; std::ostringstream values; if (!m_base_table_aux_columns.empty()) { columns << m_cloud_column_name << "," << m_base_table_aux_columns; values << "pc," << m_base_table_aux_values; } else { columns << m_cloud_column_name; values << "pc"; } int nPCPos = 1; int nSchemaPos = 1; nSchemaPos++; int nPos = nSchemaPos; // Bind column position if (!m_base_table_boundary_column.empty()) { columns << "," << m_base_table_boundary_column; nPos++; values <<", SDO_GEOMETRY(:"<<nPos; nPos++; values <<", :"<<nPos<<")"; } std::ostringstream s_srid; std::ostringstream s_geom; std::ostringstream s_schema; // IsGeographic(srid); if (m_srid == 0) { s_srid << "NULL"; } else { s_srid << m_srid; } s_schema << "xmltype(:"<<nSchemaPos<<")"; std::string eleminfo = CreatePCElemInfo(); pdal::Bounds<double> base_table_bounds = getDefaultedOption<pdal::Bounds<double> >("base_table_bounds"); if (base_table_bounds.empty()) { if (IsGeographic(m_srid)) { base_table_bounds.setMinimum(0, -179.99); base_table_bounds.setMinimum(1, -89.99); base_table_bounds.setMinimum(2, 0.0); base_table_bounds.setMaximum(0, 179.99); base_table_bounds.setMaximum(1, 89.99); base_table_bounds.setMaximum(2, 20000.0); } else { base_table_bounds.setMinimum(0, 0.0); base_table_bounds.setMinimum(1, 0.0); base_table_bounds.setMinimum(2, 0.0); base_table_bounds.setMaximum(0, 100.0); base_table_bounds.setMaximum(1, 100.0); base_table_bounds.setMaximum(2, 20000.0); } } s_geom << " mdsys.sdo_geometry("<< m_gtype <<", "<<s_srid.str()<<", null,\n" " mdsys.sdo_elem_info_array"<< eleminfo <<",\n" " mdsys.sdo_ordinate_array(\n"; s_geom << base_table_bounds.getMinimum(0) << "," << base_table_bounds.getMinimum(1) << ","; if (m_is3d) { s_geom << base_table_bounds.getMinimum(2) << ","; } s_geom << base_table_bounds.getMaximum(0) << "," << base_table_bounds.getMaximum(1); if (m_is3d) { s_geom << "," << base_table_bounds.getMaximum(2); } s_geom << "))"; boost::uint32_t dimensions = 8; oss << "declare\n" " pc_id NUMBER := :"<<nPCPos<<";\n" " pc sdo_pc;\n" "begin\n" " -- Initialize the Point Cloud object.\n" " pc := sdo_pc_pkg.init( \n" " '"<< m_base_table_name<<"', -- Table that has the SDO_POINT_CLOUD column defined\n" " '"<< m_cloud_column_name<<"', -- Column name of the SDO_POINT_CLOUD object\n" " '"<< m_block_table_name <<"', -- Table to store blocks of the point cloud\n" " 'blk_capacity="<< capacity <<"', -- max # of points per block\n" << s_geom.str() << ", -- Extent\n" " 0.5, -- Tolerance for point cloud\n" " "<<dimensions<<", -- Total number of dimensions\n" " NULL," " NULL," " "<< s_schema.str() <<");\n" " :"<<nPCPos<<" := pc.pc_id;\n" " -- Insert the Point Cloud object into the \"base\" table.\n" " insert into " << m_base_table_name << " ( ID, "<< columns.str() << ") values ( pc.pc_id, " << values.str() << ");\n" " " "end;\n"; Statement statement = Statement(m_connection->CreateStatement(oss.str().c_str())); statement->Bind(&m_pc_id); OCILobLocator* schema_locator ; OCILobLocator* boundary_locator ; std::string schema_data; bool pack = getOptions().getValueOrDefault<bool>("pack_ignored_fields", true); if (pack) { schema::index_by_index const& idx = buffer_schema.getDimensions().get<schema::index>(); log()->get(logDEBUG3) << "Packing ignored dimension from PointBuffer " << std::endl; boost::uint32_t position(0); pdal::Schema clean_schema; schema::index_by_index::size_type i(0); for (i = 0; i < idx.size(); ++i) { if (! idx[i].isIgnored()) { Dimension d(idx[i]); d.setPosition(position); // Wipe off parent/child relationships if we're ignoring // same-named dimensions d.setParent(boost::uuids::nil_uuid()); clean_schema.appendDimension(d); position++; } } schema_data = pdal::Schema::to_xml(clean_schema); } else { schema_data = pdal::Schema::to_xml(buffer_schema); } char* schema = (char*) malloc(schema_data.size() * sizeof(char) + 1); strncpy(schema, schema_data.c_str(), schema_data.size()); schema[schema_data.size()] = '\0'; statement->WriteCLob(&schema_locator, schema); statement->Bind(&schema_locator); std::ostringstream wkt_s; if (!m_base_table_boundary_column.empty()) { if (!FileUtils::fileExists(m_base_table_boundary_wkt)) { if (!IsValidWKT(m_base_table_boundary_wkt)) { std::ostringstream oss; oss << "WKT for base_table_boundary_wkt was not valid and '" << m_base_table_boundary_wkt << "' doesn't exist as a file"; throw pdal::pdal_error(oss.str()); } wkt_s << m_base_table_boundary_wkt; } else { std::string wkt = LoadSQLData(m_base_table_boundary_wkt); if (!IsValidWKT(wkt)) { std::ostringstream oss; oss << "WKT for base_table_boundary_wkt was from file '" << m_base_table_boundary_wkt << "' is not valid"; throw pdal::pdal_error(oss.str()); } wkt_s << wkt; } } std::string wkt_string = wkt_s.str(); char* wkt = (char*) malloc(wkt_string.size() * sizeof(char)+1); strncpy(wkt, wkt_string.c_str(), wkt_string.size()); wkt[wkt_string.size()] = '\0'; if (!m_base_table_boundary_column.empty()) { statement->WriteCLob(&boundary_locator, wkt); statement->Bind(&boundary_locator); statement->Bind((int*)&m_srid); } try { statement->Execute(); } catch (std::runtime_error const& e) { std::ostringstream oss; oss << "Failed at creating Point Cloud entry into " << m_base_table_name << " table. Does the table exist? " << e.what(); throw pdal_error(oss.str()); } free(wkt); try { Option& pc_id = getOptions().getOptionByRef("pc_id"); pc_id.setValue(m_pc_id); } catch (pdal::option_not_found&) { Option pc_id("pc_id", m_pc_id, "Point Cloud Id"); getOptions().add(pc_id); } }
void Writer::CreateSDOEntry() { boost::uint32_t precision = getDefaultedOption<boost::uint32_t>("stream_output_precision"); std::ostringstream oss; std::ostringstream oss_geom; oss.setf(std::ios_base::fixed, std::ios_base::floatfield); oss.precision(precision); std::ostringstream s_srid; if (m_srid == 0) { s_srid << "NULL"; } else { s_srid << m_srid; } double tolerance = 0.05; pdal::Bounds<double> e = m_bounds; if (IsGeographic(m_srid)) { // FIXME: This should be overrideable e.setMinimum(0,-180.0); e.setMaximum(0,180.0); e.setMinimum(1,-90.0); e.setMaximum(1,90.0); e.setMinimum(2,0.0); e.setMaximum(2,20000.0); tolerance = 0.0005; } oss << "INSERT INTO user_sdo_geom_metadata VALUES ('" << m_block_table_name << "','blk_extent', MDSYS.SDO_DIM_ARRAY("; oss << "MDSYS.SDO_DIM_ELEMENT('X', " << e.getMinimum(0) << "," << e.getMaximum(0) <<"," << tolerance << ")," "MDSYS.SDO_DIM_ELEMENT('Y', " << e.getMinimum(1) << "," << e.getMaximum(1) <<"," << tolerance << ")"; if (m_is3d) { oss << ","; oss <<"MDSYS.SDO_DIM_ELEMENT('Z', "<< e.getMinimum(2) << "," << e.getMaximum(2) << "," << tolerance << ")"; } oss << ")," << s_srid.str() << ")"; run(oss); oss.str(""); }